黑马程序员——Java语言基础：集合框架（Collection、Map，工具类Collections、Arrays）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
集合框架
一、概述 1.Java中集合类的关系图：
2.集合框架出现的原因：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

※ 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。 ※数组中可以存储基本数据类型，集合只能存储对象。

3.集合框架的特点：只用于存储对象；长度可变；可以存储不同类型的对象。
二、Collection 1. Collection的共性方法：增、删、改、查、取交集例：

public static void base_method()
{
//创建集合容器，使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1.添加元素
al.add("java01");//add(Object obj)
al.add("java02");
al.add("java03");
al.add("java04");
//打印集合
sop(al);
//2.获取个数，集合长度
sop("size:"+al.size());
//3.删除元素
al.remove("java02");  //al.clear();  清空集合
sop(al);
//4.判断元素
sop("java03是否存在？  "+al.contains("java03"));
sop("集合是否为空？  "+al.isEmpty());
}
<pre name="code" class="java">public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");

al1.retainAll(al2); //取交集，al1中只会存储和al2相同的元素
al1.removeAll(al2); //去交集，al1中只会存储和al2不相同的元素
sop("al1:"+al1+"    al2:"+al2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}

※ 集合中存储的都是对象的引用（地址）2. 迭代器：

（1）迭代器是取出集合中元素的方式

对于集合的元素取出这个动作：当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述，把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同，所以取出的动作细节也不一样，但都具有共性内容：判断和取出，那么就可以将这些共性抽取。这些内部类都符合一个规则（或者说都抽取出来一个规则），就是Iterator，并通过一个对外提供的方法：iterator(); 来获取集合的取出对象。

※ 因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

（2）迭代的常见操作

hasNext();//有下一个元素，返回真，作为迭代器的条件

next();//取出下一个元素

remove();//移除

※ 在迭代时循环中next调用一次，就要hasNext判断一次。

两种表现形式：

a.
 for(Iterator iter = a.iterator();iter.hasNext();  )
{
<span style="white-space:pre"></span>System.out.println(iter.next());
}
b.

Iteratoriter = a.iterator();
while(iter.hasNext())
{
<span style="white-space:pre"></span>System.out.println(iter.next());
}

三、List集合

1. 概述：元素是有序的，可以重复，因为该集合体系有索引

List

|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

2. 特有方法：

※ 凡是可以操作角标的方法都是该体系特有的方法。

（1）增

booleanadd(index,element); 指定位置添加元素

BooleanaddAll(index,Collection); 在指定位置增加给定集合中的所有元素

若省略位置参数，则在当前集合的后面依次添加元素

（2）删

Booleanremove(index); 删除指定位置的元素

（3）改

set(index,element); 修改指定位置的元素。

（4）查

get(index); 通过角标获取元素

subList(from,to); 获取部分对象元素

（5）其他

listIterator(); List特有的迭代器（Iterator迭代时不可以通过集合对象的方法操作集合中的元素）

可以在迭代时对集合元素进行增、删、改、查

indexOf(obj); 获取元素第一次出现的位置，如果没有则返回-1

※ List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

3. LinkedList

特有方法：

（1）增

addFirst();

addLast();

（2）获取：获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

getFirst();

getLast();

（3）删：获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

※ 在JDK1.6以后，出现了替代方法。

（1）增

offFirst();

offLast();

（2）获取：获取元素，但是不删除。如果集合中没有元素，会返回null。

peekFirst();

peekLast();

（3）删：获取元素，并删除元素。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

例：

<span style="white-space:pre"></span>public class LinkedListDemo 
<span style="white-space:pre"></span>{

<span style="white-space:pre"></span>public static void main(String[] args) 
<span style="white-space:pre"></span>{
LinkedList link = new LinkedList();
link.addFirst("java01");//addFirst：04.03.02.01，addLast：01.02.03.04
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
sop(link);
sop(link.getFirst());
sop(link.getLast());

sop(link.removeFirst());//先进后出；removeLast先进先出
sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.removeFirst());  //正向取。 removeLast反向取
}
<span style="white-space:pre"></span>}
<span style="white-space:pre"></span>public static void sop(Object obj)
<span style="white-space:pre"></span>{
<span style="white-space:pre"></span>System.out.println(obj);
<span style="white-space:pre"></span>}

<span style="white-space:pre"></span>}

4. ArrayList

练习：

/*
 * 将自定义对象作为元素，存储到ArrayList集合中，并去除重复元素
 * 比如：人对象：同姓名同年龄视为同一个人，为重复元素
 * 
 * 思路：1.对人描述，将数据封装进人对象
 *  2.定义容器，将人存入
 *  3.取出
 * 
 * List集合判断元素是否相同，依据是元素的equals方法。
 */
<pre name="code" class="java" style="line-height: 26px;">import java.util.*;
class Person{private String name;private int age;public boolean equals(Object obj)//重写equals方法{if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"..."+p.name);return this.name.equals(p.name)&&this.age==p.age;}Person(String name,int age){this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}}public class ArrayListTest2{public static void main(String[] args) {ArrayList al = new ArrayList();al.add(new Person("lisi01",30));al.add(new Person("lisi02",32));al.add(new Person("lisi02",32));al.add(new Person("lisi03",33));al.add(new Person("lisi04",35));al.add(new Person("lisi04",35));al = singleElement(al);Iterator it = al.iterator();while(it.hasNext()){Person p = (Person) it.next();sop(p.getName()+": :"+p.getAge());}}public static ArrayList singleElement(ArrayList al){ArrayList newAl = new ArrayList();Iterator it = al.iterator();while(it.hasNext()){Object obj = it.next();if(!newAl.contains(obj)) //contains调用的是Person的equals方法newAl.add(obj);}return newAl;}public static void sop(Object obj){System.out.println(obj);}}

※ 增删操作频繁，使用LinkedList；增删操作不频繁，两者都可用；增删和查询操作同时涉及，使用ArrayList

※ ArrayList更常用

四、Set

1. 概述：元素是无序（存入和取出的顺序不一定一致）的，且不可以重复。

Set

|--HashSet

|--TreeSet

※ Set集合的功能和Collection是一致的。

2. HashSet：底层数据结构是哈希表，线程不同步。

保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为 true（ArrayList判断只依赖equals）

例：

/*
 * 往HashSet集合中存入自定义对象
 * 姓名和年龄相同为同一个人，重复元素
 */
<pre name="code" class="java" style="line-height: 26px;">import java.util.*;
class HashSetTest{public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));hs.add(new Person("a2",12));hs.add(new Person("a3",13));hs.add(new Person("a2",12));hs.add(new Person("a4",14));sop("a1:"+hs.contains(new Person("a1",11)));sop("a3:"+hs.remove(new Person("a3",13)));Iterator it = hs.iterator();while(it.hasNext()){Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}public static class Person{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}public int hashCode() //复写Object类的hashCode()方法{System.out.println(this.name+".....hashCode");return name.hashCode()+age*39; //为了尽量保证哈希值唯一*39}public boolean equals(Object obj)//复写equals()方法{if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"...equals..."+p.name);return this.name.equals(p.name)&&this.age==p.age;//先判断姓名，再判断年龄}public String getName() {return name;}public int getAge() {return age;}}}

3. TreeSet：

※ 底层数据结构是二叉树，可以对Set集合中的元素进行排序，默认按照字母的自然排序。

※ 保证元素唯一性的依据：compareTo方法，return 0

※ 排序方式：

（1）第一种方式：让元素自身具备比较性，元素需要实现comparable接口，覆盖compareTo方法也称为元素的自然排序，或叫做默认顺序。

例：
/*
 * 给TreeSet集合中存储自定义对象学生，按年龄排序
 */
import java.util.*;
public class TreeSetDemo
{
public static void main(String[] args) 
{
TreeSet ts = new TreeSet();

ts.add(new Student("lisi",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
ts.add(new Student("lisi08",19));

Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.name+"..."+stu.age);
}
}
public static class Student implements Comparable //该接口强制让学生具备比较性
{
private String name;
private int age;

Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;

System.out.println(this.name+"...comapreto..."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
return this.name.compareTo(s.name);
return -1;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}
}
}
（2）第二种方式：比较器，当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式，定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

※ 比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。

※ 排序时，当主要条件相同时，一定要判断次要条件

※ 当两种排序都存在时，以比较器为主

例：

import java.util.*;
class TreeSetDemo2
{
public static void main(String[] args) 
{
TreeSet ts = new TreeSet(new MyCompare());

ts.add(new Student("lisi01",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",18));
ts.add(new Student("lisi007",29));

Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性
{
private String name;
private int age;

Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"...comapreto..."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
return this.name.compareTo(s.name);
return -1;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}

五、泛型

1. 概念：JDK1.5版本后出现的新特性，用于解决安全问题，是一个安全机制

2. 好处：

（1）将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全

（2）避免了强制转换

3. 泛型格式：通过<>来定义要操作的引用数据类型

※ 在使用java提供的对象时，什么时候写泛型：通常在集合框架中很常见，只要见到<>就要定义泛型

※ 其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

例：
public class GenericDemo 
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();//泛型

al.add("abc01");
al.add("abc0991");
al.add("abc014");

Iterator<String> it = al.iterator();

while(it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
4. 泛型

（1）泛型类：当类中要操作的引用数据类型不确定时，定义泛型类。

例：
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
（2）泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上

※ 静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上

※ 定义泛型放在返回值前面

例：
class Demo
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)
{
System.out.println("print:"+q);
}
}
（3）泛型限定：（用于进行泛型扩展）

? extends E：可以接收E类型或者E的子类型。（上限）

? super E：可以接收E类型或者E的父类型。（下限）

※ "?"通配符，也可以理解为占位符

六、Map集合

1. 概述：Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，

即键（Key）

※ 该集合存储键值对，一对一对往里存

※ 要保证键的唯一性。

2. Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值（该集合是线程同步的）
|--Hashmap：底层是哈希表数据结构，允许使用null键null值（该集合是不同步的）

|--Treemap ：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键排序

※ 和Set很像，其实Set底层就是使用的Map集合。

3. 常用方法

（1）添加： put(K key,V value);

putAll(Map<? extends K , ? extends V>m);

（2）删除：clear();

  remove(Object key);

（3）判断：containsValue(Object value);

  containsKey(Object key);

  isEmpty();

（4）获取：get (Object key);

  size();

  values();

※  keySet(); 将map中的所有键存入到Set集合，因为Set有迭代器，通过迭代器取出所有的键

再通过get方法获取每个键的对应值

  entrySet(); 将map中的映射关系取出，存入到set集合

例：
/*
 * 每一个学生都有对应的归属地。
 * 学生Student，地址String
 * 学生属性：姓名，年龄。姓名和年龄相同的视为同一个学生，保证学生唯一性
 * 
 * 1.描述学生
 * 2.定义map容器，将学生作为键，地址作为值，存入
 * 3.获取map集合中的元素
 */
import java.util.*;
class Student implements Comparable<Student>
{
private String name;//描述学生属性
private int age;
public Student(String name, int age)
{
super();
this.name = name;
this.age = age;
}
public int compareTo(Student s)//复写compareTo方法
{
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
//复写hashCode方法
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
//复写equals方法
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

public String getName() {
return name;
}
public int getAge() {
return age;
}
public String toString()
{
return name+":"+age;
}

}
public class MapTest 
{
public static void main(String[] args) 
{
HashMap<Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",21), "beijing");//添加元素
hm.put(new Student("lisi1",21), "tianjin");//会覆盖前一个
hm.put(new Student("lisi2",22), "shanghai");
hm.put(new Student("lisi3",23), "nanjing");
hm.put(new Student("lisi4",24), "wuhan");

//第一种取出方式 keySet
Set<Student> keySet = hm.keySet();//获取map集合所有键的Set集合
Iterator<Student> it = keySet.iterator();//获取其迭代器
while(it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);//有了键，通过map集合的get方法获取其对应的值
//System.out.println(stu+".."+addr);
}
//第二种取出方式 entrySet
Set<Map.Entry<Student, String>> entrySet = hm.entrySet();//取出映射关系
Iterator<Map.Entry<Student, String>> iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student, String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+".."+addr);
}
}
}
※ 关于Map.Entry：

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。

※ 为何要定义在其内部的原因：

a.Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

b.并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

4. TreeMap：用于给Map集合中的键排序

例：

/*
需求：对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的，所以使用可以排序的Map集合，TreeMap
*/
import java.util.*;
class MapTest2
{
public static void main(String[] args)
{
TreeMap<Students,String> t = new TreeMap<Students,String>(new StuNameComparator());
t.put(new Student("lisi1",21), "beijing");
t.put(new Student("lisi2",22), "shanghai");
t.put(new Student("lisi3",23), "nanjing");
t.put(new Student("lisi4",24), "wuhan");

Set<Map.Entry<Students,String>> entrySet = t.entrySet();

Iterator<Map.Entry<Students,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Students,String> me = it.next();

Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
//学生类同上
//自定义比较器，比较姓名
class StuNameComparator implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num = s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTonew Integer(s2.getAge()));
return num;
}
}

5.Map集合扩展：

在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。

例：

/* 
map扩展知识。 
map集合被使用是因为具备映射关系。 
以下是班级对应学生，而学生中学号对应着姓名的映射关系： 
"yureban"   Student("01" "zhangsan"); 

"yureban" Student("02" "lisi"); 

"jiuyeban" "01" "wangwu"; 
"jiuyeban" "02" "zhaoliu"; 

就如同一个学校有多个教室。每一个教室都有名称。 
*/  
import java.util.*;   
class  MapExpandKnow  
{  
    public static void main(String[] args)   
    {  
        //预热班集合  
        HashMap<String,String> yureban=new HashMap<String,String>();  
        //就业班集合  
        HashMap<String,String> jiuyeban=new HashMap<String,String>();  
        //学校集合  
<span style="white-space:pre"></span>HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();  

        //学校中班级集合和名称的映射  
        czbk.put("yureban",yureban);  
        czbk.put("jiuyueban",jiuyeban);  

<span style="white-space:pre"></span>//预热班级中学号与姓名的映射  
        yureban.put("01","zhangsan");  
        yureban.put("02","lisi");  

        //就业班级中学号与姓名的映射  
        jiuyeban.put("01","wangwu");  
        jiuyeban.put("02","zhouqi");  

<span style="white-space:pre"></span>//直接显示全部学生信息  
        getAllStudentInfo(czbk);  

    }  
    //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少  
    public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式  
        {  
            String s= it.next();//班级名称  
            System.out.println(s+":");  
            HashMap<String,String> stu=hm.get(s);//班级集合  

            getStudentInfo(stu);  
        }  
    }  

    //获取班级中学生的信息，包括姓名和学号  
    public static void getStudentInfo(HashMap<String,String> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )  
        {  
            String key=it.next();//学号  
            String value=hm.get(key);//姓名  
            System.out.println(key+"..."+value);  
        }  
    }  
}

七、集合框架工具类

1. Collections

（1）概述：Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象，并未封装特有数据。

在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。

（2）常见操作：

a.查找

Tmax(Collection<? extends T> coll);

（根据集合的自然顺序，获取coll集合中的最大元素）

Tmax(Collection<? extends T> coll,Comparator<? super T> comp);

（根据指定比较器comp的顺序，获取coll集合中的最大元素）

intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);

（二分法搜索list集合中的指定对象）

b.替换

voidfill(List<? super T> list, T obj);

（将list集合中的全部元素替换成指定对象obj）

booleanreplaceAll(List<T> lsit,T oldVal,T newVal);

（用newVal替换集合中的oldVal值）

void swap(Listlist,int i,int j);

（在指定列表的指定位置处交换元素）

c.排序

void shuffle(List<?> list);

（使用默认随机源对list集合中的元素进行随机排序）

void sort(Lsit<T> list);

（根据自然顺序对list集合中的元素进行排序）

voidsort(List<T> lsit,Comparator<? super T> c);

（根据指定比较器c的排序方式对list集合进行排序）

d.反转

reverse(List<?> list);

（反转list集合中元素的顺序）

Comparator reverseOrder();

（返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序）

ComparatorreverseOrder(Comparator<T> cmp);

（返回一个比较器，强行逆转了指定比较器的顺序）

e.同步的集合

List<T>synchronizedList(List<T> list);

（返回支持的同步（线程安全的）List集合）

Map<K,V>synchronizedList(Map<K,V> m);

（返回支持的同步（线程安全的）Map集合）

（3）与Collection的区别：

Colletion是java.util包中的接口，是集合类的基本接口，主要的子接口有list和set，都可以使用迭代器对集合进行遍历

Collections是java.util包中的类，是针对集合的一个实用工具类，包含对各种集合的搜索、查询、修改、排序、线程安全等一系列的静态方法。

2. Arrays

（1）概述：Arrays是用于操作数组的工具类，里边的方法也全是静态的，不需要创建对象。

把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。

如：contains，get，indexOf，subList等方法。

（2）常见方法

a. Lsit<T> asList(T... a); （将数组转换为集合）

※ 将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

※ 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。

※ 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

b. binarySearch(); （二分查找方法，fill()：替换方法，sort()：排序方法等）

※ 可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。

如：sort(T[]a,Comparator<? super T> c)

fill(int[]a,int from,int to)等

c. String toString(); （可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式）

（3）集合变数组

Collection接口中的toArray方法。

<T> T[] toArray (T[] a);（将集合变为指定类型的数组）

a. 指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

所以创建一个刚刚好的数组最优。

b. 将集合变数组：为了限定对元素的操作，不再需要进行增删。

八、扩展知识——1.5版本新特性

1. 高级for

（1）格式：for(数据类型变量名 :被遍历的集合（collection）或者数组) {执行语句}

※ 对集合进行遍历，只能获取集合元素，不能对集合进行操作，可以看作是迭代器的简写形式。

※ 迭代器除了遍历，还可以进行remove集合中元素的动作；如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

（2）传统for和高级for的区别：

        高级for有一个局限性，必须有被遍历的目标（集合或数组）。

        传统for遍历数组时有索引。

        建议在遍历数组的时候，使用传统for，因为传统for可以定义角标。

例：
for(int i : arr)  
        {  
            System.out.println("i:"+i);  
        }  
2. 方法的可变参数

如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。在JDK1.5版本后，就提供了一个新特性：可变参数。

可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

例：
class  ParamMethodDemo  
{  
    public static void main(String[] args)   
    {  
        show("hehe",2,3,4,5,6);  
    }  
    public static void show(String str,int... arr)//...就表示可变参数  
    {  
        System.out.println(arr.length);  
    }  
}  

※ 可变参数一定要定义在参数列表的最后面。

3. 静态导入

（1）格式：

import static java.util.Arrays.*;（导入的是Arrays这个类中的所以静态成员）

import static java.lang.System.*;（导入了Ssytem类中所以静态成员）

※ 没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。

※ 这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);

※ 当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

※ 当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。

秒客网

黑马程序员——Java语言基础：集合框架（Collection、Map，工具类Collections、Arrays）

相关文章