Java基础——集合框架

框架"/>

Java基础——集合框架

 集合框架

1.数据多了可用数组存储，对象多了可用数组或者集合存储

2.集合长度是可变的，可以存储不同类型的对象

3.实际结构中，集合存放的是对象的地址值

一. Collection接口（集合的超类）

1.其下容器底层数据结构不同，存储方式也不同 

2.集合的特殊取出方式——迭代器

方法摘要
boolean	add(E e)            确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c)            将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。添加一个集合
void	clear()            移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o)            如果此 collection 包含指定的元素，则返回 true。List集合中默认调用对象的equals()方法
boolean	containsAll(Collection<?> c)            如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o)            比较此 collection 与指定对象是否相等。
int	hashCode()            返回此 collection 的哈希码值。
boolean	isEmpty()            如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator()            返回在此 collection 的元素上进行迭代的迭代器。重点方法，特殊的取出方式
boolean	remove(Object o)            从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。List集合中默认调用对象的equals()方法
boolean	removeAll(Collection<?> c)            移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。删除交集元素
boolean	retainAll(Collection<?> c)            仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。只保留交集元素
int	size()            返回此 collection 中的元素数。
Object[]	toArray()            返回包含此 collection 中所有元素的数组。（集合转换为数组是为了限定用户对元素的操作）
<T> T[]	toArray(T[] a)            返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。（定义数组长度最好刚刚好，不然浪费内存）

Iterator接口（迭代器） 

1.知识点：每个集合类中都有一个内部类存储自己类一系列特殊的取出方法，因为每一个集合类的底层存储结构不一样。并且该内部类实现Interator接口

方法摘要
boolean	hasNext()            如果仍有元素可以迭代，则返回 true。
E	next()            返回迭代的下一个元素。
void	remove()            从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

1.List集合

重点：元素是按存入顺序存储的，元素可以重复，每个元素有索引值

特有方法摘要
boolean	add(E e)            向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element)            在列表的指定位置插入指定元素（可选操作）。（增）
boolean	addAll(int index, Collection<? extends E> c)            将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。（增）
E	remove(int index)            移除列表中指定位置的元素（可选操作）。（删）
E	set(int index, E element)            用指定元素替换列表中指定位置的元素（可选操作）。（改）
E	get(int index)            返回列表中指定位置的元素。（查）
List<E>	subList(int fromIndex, int toIndex)            返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（查）
ListIterator<E>	listIterator()            返回此列表元素的列表迭代器（按适当顺序）。（查，重要，List集合特有的取出方法）
ListIterator<E>	listIterator(int index)            返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。（查，重要，List集合特有的取出方法）
int	indexOf(Object o)            返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。（查）
int	lastIndexOf(Object o)            返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。（查）

1.1 ListIterator接口（List集合特有的迭代器，Iterator的子类）

（1）重点：Interior迭代器中当用集合方法对集合元素进行添加或者修改改操作时会抛ConcurrentModitcationException()——并发访问异常，修改异常。因为迭代器在访问集合元素，集合也在访问自己的元素不能对同一组元素进行多种同时操作。ListIterator中添加了添加或者修改改等操作来弥补父类迭代器的这个缺陷

方法摘要
void	add(E e)            将指定的元素插入列表（可选操作）。
boolean	hasNext()            以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean	hasPrevious()            如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E	next()            返回列表中的下一个元素。
int	nextIndex()            返回对 next 的后续调用所返回元素的索引。
E	previous()            返回列表中的前一个元素。
int	previousIndex()            返回对 previous 的后续调用所返回元素的索引。
void	remove()            从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void	set(E e)            用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

1.2 ArrayList类

（1）特点：数组结构，查改快，增删慢（因为有索引，插入删除会对其后的全部索引值都有影响）线程不同步。每次超过初始长度50%延长

/**
*需求：去除一个List中的重复元素（普通数据与自定义对象数据）
*思路：1.新建一个集合，把现有List集合中全部元素全部存储到新建集合中，并且去除相同元素
*	  2.当存入的时自定义对象时一定要复写该对象的equal()方法，来定义自己的比较方法，因为list集合的contain()方法会默认调用对象的equals方法比较。
*/
import java.util.*;class Person//自定义人对象
{private String name;//姓名private int age;//年龄//初始化方式Person(String name,int age){//this.name = name;this.age = age;}//自定义输出方式public String toString(){return "Person("+name+"..."+age+")";}//名称的get方法public String getName(){return name;}//年龄的get方法public int getAge(){return age;}//复写的equals比较方法public boolean equals(Object obj){Person p = (Person)obj;return name.equals(p.getName()) && age == p.getAge();}
}class java
{public static void main(String[] args){Person p1 = new Person("张三",3);Person p2 = new Person("李四",4);Person p3 = new Person("王五",5);Person p4 = new Person("张三",3);List<Person> al = Arrays.asList(p1,p2,p3,p4,p1);//重复元素集合System.out.println(al);System.out.println(delElement(al));}//删除集合中相同数据的方法public static <E> List<E> delElement(List<E> al){List<E> li = new ArrayList<E>();for(Iterator<E> it = al.iterator();it.hasNext();){E key = it.next();if(!li.contains(key))li.add(key);}return li;}
}

1.3 LinkedList类

（1）特点：链表结构，增删快，查改慢（因为链表是全连接起来的，前一个连后一个，查改需要从集合第一个开始遍历到查询处）线程不同步 

（2）方法简介

方法摘要
void	addFirst(E e)            将指定元素插入此列表的开头。存入后的数据顺序要注意，是加在最前，把前面的往后顶。被offerFirst()所替代，此方法与此集合的add()方法相同
void	addLast(E e)            将指定元素添加到此列表的结尾。存入后的数据顺序要注意，是加在最后，把后面的往前顶。被offerLast()所替代
E	getFirst()            返回此列表的第一个元素。被peekFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
E	getLast()            返回此列表的最后一个元素。被peedLast()所替代。集合为空时调用此方法会抛出NoSuchElementException
E	removeFirst()            移除并返回此列表的第一个元素。获取元素，并且删除元素，被pollFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
E	removeLast()            移除并返回此列表的最后一个元素。获取元素，并且删除元素，被pollFirst()所替代。集合为空时调用此方法会抛出NoSuchElementException
boolean	offerFirst(E e)            在此列表的开头插入指定的元素。存入后的数据顺序要注意，是加在最前，把前面的往后顶。
boolean	offerLast(E e)            在此列表末尾插入指定的元素。存入后的数据顺序要注意，是加在最后，把后面的往前顶。
E	peekFirst()            获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	peekLast()            获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	pollFirst()            获取并移除此列表的第一个元素；如果此列表为空，则返回 null。获取元素，并且删除元素
E	pollLast()            获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。获取元素，并且删除元素

（3）数据结构

    <1>.堆栈：先进后出，杯子

    <2>.队列：先进先出，水管

/**
*需求：设计一个堆栈和一个队列结构的对象接收数据
*思路：1.设计两个类，分别都具有enter方法和goOut方法来接收和释放数据
*	  2.可以用LinkedList实现两个类的底层数据结构
*/
import java.util.*;class MyStack<E>//堆栈结构
{//内部链式存储结构private LinkedList<E> ll = new LinkedList<E>();//存入数据public void enter(E e){ll.offerFirst(e);}//取出数据public E goOut(){return ll.pollFirst();}public void print(){System.out.println(ll);}
}class MyQueue<E>//队列结构
{//内部链式存储结构private LinkedList<E> ll = new LinkedList<E>();//存入数据public void enter(E e){ll.offerFirst(e);}//取出数据public E goOut(){return  ll.pollLast();}public void print(){System.out.println(ll);}
}class java
{public static void main(String[] args){MyQueue<String> ms = new MyQueue<String>();ms.enter("1");ms.enter("2");ms.enter("3");ms.print();System.out.println("出来的"+ms.goOut());ms.print();System.out.println("出来的"+ms.goOut());ms.print();System.out.println("出来的"+ms.goOut());ms.print();}
}

1.4 Vetor类

（1）特点：数组结构，线程同步，被ArrayList替代

（2）方法简介

特殊方法摘要
Enumeration<E>	elements()            返回此向量的组件的枚举。

（3）Enumeration接口（枚举，被Iterator接口代替）

方法摘要
boolean	hasMoreElements()            测试此枚举是否包含更多的元素。
E	nextElement()            如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

2.Set集合

特点：元素是无序的（存入和存储顺序不同）元素不可以重复。没有自己的特性方法

2.1 HashSet类

（1）特点：哈希表数据结构，线程不同步

（2）注意：判断hashcode，不同传入，相同则再判断equals，不同传入（同地址顺延），相同不传。add()、contains()、remove()都会经历这个流程

/**
*需求：向HashSet传入自定义对象
*思路：1.自定义对象需要复写hashCode和equals方法
*	  2.hashSet中的add、remove、contains方法都会判断上边的hashCode与equals
*/import java.util.*;class Practice
{public static void main(String[] args){HashSet<Student> hs = new HashSet<Student>();hs.add(new Student("呵呵",12));hs.add(new Student("丫丫",31));hs.add(new Student("丫丫",31));//无法传入hs.add(new Student("岂可修",12));hs.add(new Student("八嘎",31));hs.add(new Student("八嘎",31));//无法传入hs.add(new Student("大丈夫",21));hs.add(new Student("大丈夫",21));//无法传入hs.add(new Student("萌大奶",31));for(Iterator<Student> it = hs.iterator();it.hasNext();){Student s = it.next();System.out.println("姓名："+s.getName()+"-------年龄："+s.getAge());}}
}class Student
{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}//自定义对象复写hashCode方法public int hashCode(){//System.out.println(this.name+"....哈希值.....");//方便观看//对象自定义的hashCode算法return this.name.hashCode()+this.age*17;}public boolean equals(Object obj){//判断参数类型重要，不要忽视if(!(obj instanceof Student))throw new RuntimeException();Student s = (Student)obj;//System.out.println(this.name+"....等于....."+s.name);//对象自定义的比较方法return this.name.equals(s.name) && this.age == s.age;}
}

2.2 TreeSet类

（1）特点：底层是二叉树数据结构，线程不同步

（2）注意：可以对Set集合中的元素进行排序，对于自定义对象的排序需要自定义排序方式，使其具备比较性。

（3）使其具备比较性的方法1：实现Comparable接口（让元素具备比较性）

Comparable（接口）

方法摘要
int	compareTo(T o)            比较此对象与指定对象的顺序。

代码实现如下：

    <1>.步骤：new TreeSet()集合会按元素的自然顺序排序，然后就是是自定义对象具有比较性

    <2>.特殊知识点：如果按照代码的上下顺序输出结果，可使compareTo方法返回值为1或者-1

/**
*需求：Tree集合对自定义对象的比较性实现方法1
*思路：1.比较性接口是Comparable
*	  2pareTo方法返回正数则大，负数则小，0则是等于
*	  3.返回值为0视为两个对象相同，将不放进集合中
*/
import java.util.*;class java
{public static void main(String[] args){TreeSet<Student> hs = new TreeSet<Student>();hs.add(new Student("伊利亚斯菲尔",14));hs.add(new Student("爱丽丝菲尔",15));hs.add(new Student("阿尔托利亚",16));hs.add(new Student("远坂凛",15));hs.add(new Student("间桐樱",15));for(Iterator<Student> it = hs.iterator();it.hasNext();){Student s = it.next();System.out.println(s.getName()+"\t永远的青春"+s.getAge());}}
}class Student implements Comparable<Student>//该接口让学生具有比较性
{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}public int compareTo(Student t){if((age - t.age)==0)//主要条件相同要排序次要条件return namepareTo(t.name);//字符串自己的compareTo方法elsereturn age - t.age;//可根据来改变排序次序，倒叙，正序}
}

（3）使其具有比较性的方法2：实现Comparator接口（元素具有的比较性不是被我们所要，让集合具备比较性）

   <1>.步骤：在集合初始化时，就有了比较方式。可以用new TreeSet(Conparator c)使比较性具有比较性，来实现元素的顺序

/**
*需求：Tree集合对自定义对象的比较性实现方法2
*思路：1.使集合具有比较性
*	  2.通过向TreeSet传入比较器来使其具有比较性
*/
import java.util.*;class java
{public static void main(String[] args){//向TreeSet传入比较器使其具有比较性（这里使用的是匿名内部类）接口增加了扩展性TreeSet<Student> hs = new TreeSet<Student>(new Comparator<Student>(){public int compare(Student s1,Student s2){if((s1.getAge()-s2.getAge())==0)return s1.getName()pareTo(s2.getName());elsereturn s1.getAge()-s2.getAge();}});hs.add(new Student("伊利亚斯菲尔",14));hs.add(new Student("爱丽丝菲尔",15));hs.add(new Student("阿尔托利亚",16));hs.add(new Student("远坂凛",15));hs.add(new Student("间桐樱",15));for(Iterator<Student> it = hs.iterator();it.hasNext();){Student s = it.next();System.out.println(s.getName()+"\t永远的青春"+s.getAge());}}
}class Student
{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}
}

二. Map集合

1.特点：该集合存储键值对，一对一对往进存，而且要保证键的唯一性

方法摘要
V	put(K key, V value)            将指定的值与此映射中的指定键关联（可选操作）。(增加，当键重复时，会覆盖原先的值，并且此方法会返回被覆盖的值）
void	putAll(Map<? extends K,? extends V> m)            从指定映射中将所有映射关系复制到此映射中（可选操作）。(增加）
V	remove(Object key)            如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。(删除）
void	clear()            从此映射中移除所有映射关系（可选操作）。(删除）
boolean	containsKey(Object key)            如果此映射包含指定键的映射关系，则返回 true。(判断）
boolean	containsValue(Object value)            如果此映射将一个或多个键映射到指定值，则返回 true。(判断）
boolean	equals(Object o)            比较指定的对象与此映射是否相等。(判断）
boolean	isEmpty()            如果此映射未包含键-值映射关系，则返回 true。(判断）
V	get(Object key)            返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。(获取，能过传入null）
int	size()            返回此映射中的键-值映射关系数。(获取）
Collection<V>	values()            返回此映射中包含的值的 Collection 视图。(获取）
Set<K>	keySet()            返回此映射中包含的键的 Set 视图。(重要）
Set<Map.Entry<K,V>>	entrySet()            返回此映射中包含的映射关系的 Set 视图。(重要）

Map.Entry<K,V>接口

1.把Map集合中的关系存入到Set集合中

方法摘要
boolean	equals(Object o)            比较指定对象与此项的相等性。
K	getKey()            返回与此项对应的键。(取关系的键）
V	getValue()            返回与此项对应的值。(取关系的值）
int	hashCode()            返回此映射项的哈希码值。
V	setValue(V value)            用指定的值替换与此项对应的值（可选操作）。

1.HashMap

（1）特点：底层是哈希表数据结构，线程不同步

（2）集合中两种取出方法

class StudentOfMap {/***需求：每一个学生都有对应的归属地，学生Student，地址String，学生属性姓名，年龄，姓名年龄相同视为同一个学生，保证学生唯一性 *思路：1.定义一个学生类，复写equals、hashCode、compareTo方法*	   2.定义HashMap集合，键存储学生，值存储地址，以为健必须保证唯一性* @param args*/public static void main(String[] args) {Map<Student,String> map = new HashMap<Student,String>();map.put(new Student("王逊",14), "昌平区");map.put(new Student("王逊",151), "昌平区");map.put(new Student("张欣",15), "朝阳区");map.put(new Student("张欣",15), "朝阳区");map.put(new Student("郑天成",167), "东城区");//keySet取出方式Set<Student> ss = map.keySet();for(Student s : ss){System.out.println(s+","+map.get(s));}System.out.println();//entrySet取出方式Set<Map.Entry<Student, String>> entry = map.entrySet();for(Map.Entry<Student, String> s : entry){System.out.println(s.getKey()+","+s.getValue());}}
}
//学生类
class Student implements Comparable<Student> {private String name;//姓名private int age;//年龄Student(String name,int age){this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}//哈希code方法public int hashCode() {return this.name.hashCode()+age*23;}//equals方法public boolean equals(Object obj) {if(!(obj instanceof Student))throw new ClassCastException("传入类型错误");Student s = (Student)obj;return this.name.equals(s.getName()) && this.age == s.getAge();}//相比较的方法public int compareTo(Student o) {if(age == o.getAge())return this.namepareTo(o.getName());elsereturn age-o.getAge();}//字符串输出方法public String toString() {return name+"..."+age;}}

（3）取出一个字符串中全部相同元素

public class Test2 {/*** "avadsvasdgsagas"这个字符串以这个形式：打印*/public static void main(String[] args) {String str = "avadsvasdgsagas";Map<String,Integer> hm = new HashMap<String,Integer>();for(int x = 0;x<str.length();x++){String ch = str.charAt(x)+"";Integer value = hm.get(ch);//获取键对应的值if(value==null)//键不存在，存入hm.put(ch, 1);else//键存在，值自增hm.put(ch,++value);}Set<Map.Entry<String, Integer>> entry = hm.entrySet();//取出方法for(Map.Entry<String, Integer> e : entry){System.out.print(e.getKey()+"("+e.getValue()+")");//打印方法}}
}

2.TreeMap

（1）特点：底层是二叉树数据结构，线程不同步

3.Hashtable

（1）特点：底层是哈希表结构，不允许使用null键null值，线程同步

三. 集合工具包

1.Collections类

方法摘要
static <T extends Comparable<? super T>>  void	sort(List<T> list)            根据元素的自然顺序 对指定列表按升序进行排序。（方法上的泛型，指集合中元素必须实现Comparable接口）
static <T> void	sort(List<T> list, Comparator<? super T> c)            根据指定比较器产生的顺序对指定列表进行排序。（自定义传入比较器）
static <T> int	binarySearch(List<? extends Comparable<? super T>> list, T key)            使用二分搜索法搜索指定列表，以获得指定对象。（如果未查找到，返回的是 “-(插入点) - 1“）
static <T> int	binarySearch(List<? extends T> list, T key, Comparator<? super T> c)            使用二分搜索法搜索指定列表，以获得指定对象。
static <T> void	copy(List<? super T> dest, List<? extends T> src)            将所有元素从一个列表复制到另一个列表。
static <T> void	fill(List<? super T> list, T obj)            使用指定元素替换指定列表中的所有元素。
static <T> boolean	replaceAll(List<T> list, T oldVal, T newVal)            使用另一个值替换列表中出现的所有某一指定值。（替换集合中一个元素为指定元素）
static void	swap(List<?> list, int i, int j)            在指定列表的指定位置处交换元素。
static void	reverse(List<?> list)            反转指定列表中元素的顺序。
static <T> Comparator<T>	reverseOrder()            返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。（反转）
static <T> Comparator<T>	reverseOrder(Comparator<T> cmp)            返回一个比较器，它强行逆转指定比较器的顺序。（反转）
static void	shuffle(List<?> list)            使用默认随机源对指定列表进行置换。
static void	shuffle(List<?> list, Random rnd)            使用指定的随机源对指定列表进行置换。
static <T extends Object & Comparable<? super T>>  T	max(Collection<? extends T> coll)            根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T	max(Collection<? extends T> coll, Comparator<? super T> comp)            根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T extends Object & Comparable<? super T>>  T	min(Collection<? extends T> coll)            根据元素的自然顺序 返回给定 collection 的最小元素。
static <T> T	min(Collection<? extends T> coll, Comparator<? super T> comp)            根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static <T> List<T>	emptyList()            返回空的列表（不可变的）。
static <K,V> Map<K,V>	emptyMap()            返回空的映射（不可变的）。
static <T> Set<T>	emptySet()            返回空的 set（不可变的）。
static <T> boolean	addAll(Collection<? super T> c, T... elements)            将所有指定元素添加到指定 collection 中。（方便的向集合中添加元素的方法）
static <T> Collection<T>	synchronizedCollection(Collection<T> c)           返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T>	synchronizedList(List<T> list)           返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V>	synchronizedMap(Map<K,V> m)           返回由指定映射支持的同步（线程安全的）映射。
static <T>Set<T>	synchronizedSet(Set<T> s)           返回指定 set 支持的同步（线程安全的）set。

2.Arrays类

注意：各种基本数据类型参数列表的重载未包括

方法摘要
static <T> List<T>	asList(T... a)           返回一个受指定数组支持的固定大小的列表。（把数组变成List集合）
static <T> int	binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)           使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static <T> int	binarySearch(T[] a, T key,Comparator<? super T> c)           使用二分搜索法来搜索指定数组，以获得指定对象。
static <T> T[]	copyOf(T[] original, int newLength)           复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static <T> T[]	copyOfRange(T[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。（复制一个范围）
static <T> T[]	copyOfRange(T[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static boolean	equals(Object[] a,Object[] a2)           如果两个指定的 Objects 数组彼此相等，则返回 true。（比较两个数组中的值是否相同）
static void	fill(Object[] a, int fromIndex, int toIndex,Object val)           将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void	fill(Object[] a,Object val)           将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void	sort(short[] a, int fromIndex, int toIndex)           对指定 short 型数组的指定范围按数字升序进行排序。
static <T> void	sort(T[] a,Comparator<? super T> c)           根据指定比较器产生的顺序对指定对象数组进行排序。
static <T> void	sort(T[] a, int fromIndex, int toIndex,Comparator<? super T> c)           根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
static String	toString(Object[] a)           返回指定数组内容的字符串表示形式。

数组变为集合： （1）可以用集合的中的方法和思想操作数组 （2）不能使用增加删除的方法操作该集合 （3）基本数据类型数组Arrays.asList(arr)方法不能识别，会自动识别为只有一个元素，该元素为一个数组。