javaAPI-集合

集合

集合框架

集合框架是通过不断抽取共性而得来的。

当抽取到最顶层时，得到了Collection接口。

为什么会出现这么多容器呢？

因为每一个容器对数据的存储方式都有不同，所以进行了单独的划分。这个存储方式称之为：数据结构。

Collection

Collection：集合向上抽取出来的，是集合的共性内容，属于集合框架的一部分。

Collection定义了集合框架的共性功能：

1.添加

                  add(e);//添加指定元素

                  addAll(collection);//添加所有

2.删除

                 remove(e);//删除指定元素

                 removeAll(collection);

                 clear();//清空集合

3.判断

                contains(e);//是否存在

                isEmpty();//是否为空

4.获取

              iterator();//迭代器

              size();//获取个数，集合长度。

              retainAll();//获取交集，获取相同元素

              removeAll();//去除相同元素

5.集合变数组

            toArray();

注意：

             1.add方法的参数类型是Object。以便于接收任意类型对象。

             2.集合中存储的都是对象的引用(地址)。

Iterator（迭代器）

什么是迭代器？

其实就是集合取出元素的方式。它返回的是一个接口(Iterator接口)，接口型引用只能指向自己的子类对象。

Iterator的方法：

1.  next():返回迭代的下一个元素

2.    hasNext():如果仍有元素可以迭代，则返回true

3.    remove():从迭代器指向的collection中移除迭代器返回的最后一个元素

示例：取出ArrayList里的所有元素

ArrayList al = new ArrayList();for(Iterator it = al.iterator();it.hasNext();){System.out.println(it.next());}

List

List集合的方法:凡是可以操作角标的方法都是该体系特有的方法。

增

                 add(index,element);

                 addAll(index,Collection);

删

                 remove(index);

改

                 set(index,element);

查

                 get(index);

                 subList(from,to);

                 listIterator();

注意：list集合有自己特有的查看方式，就是for循环的遍历。for(int x=0;x< .size();x++){System.out.println(.get(x));}

ListIterator(列表迭代器)

List集合特有的迭代器，ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException(并发修改异常)。

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。

如果想要其他的操作如添加，修改等，就需要使用其子接口：ListIterator。该接口只能通过List集合的listIterator方法获取。

ListIterator中方法：

                         hasNext();

                         next();

                         remove();

                         add(E e):将指定元素插入列表。

                         nextIndex():返回对next的后续调用所返回元素的索引。

                         hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回true。

                         previous():返回列表中的前一个元素。

                         previousIndex():返回对previous的后续调用所返回元素的索引。

                         Set(E e):用指定元素替换next或previous返回的最后一个元素。

示例：在迭代过程中，准备添加或者删除元素

ListIterator li = al.listIterator();while(li.hasNext())//正遍历{Object obj = li.next();if(obj.equals("java02"))//li.add("java009");//li.remove();//将java002的引用从集合中删除li.set("java006");｝while(li.hasPrevious())//反向取，逆遍历{sop("pre::"+li.previous());}

List集合具体对象

Collection：顶层接口

               |--List:元素是有序(怎么存进去的怎么取出来)的，元素可以重复。因为该集合体系有索引。

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

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

                         |--Vector:底层是数组数据结构。1.0版本线程同步，效率低，被ArrayList替代了。

        这三个是常见的子类对象，子类对象的出现是因为底层的数据结构不同而出现的。

 

              |--Set:元素是无序(存入和取出的顺序不一定一致)的，元素不可以重复。该集合体系没有索引。

                         |--HashSet:底层数据结构是哈希表。线程是不同步的

                               HashSet是如何保证元素唯一性的呢？

                             是通过元素的两个方法，hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals。

注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

                         |--TreeSet:可以对Set集合中的元素进行排序,底层数据结构是二叉树。

                              保证元素唯一性的依据是compareTo方法return 0;。

 

      ArrayList与Vector：它们都是数组结构。

      数组结构特点是：它是固定长度的，而集合是可变长度的。

 

那什么叫可变长度的数组呢？

      ArrayList的特点：

      ArrayList默认的长度是10，当你超过这个长度的时候，在往里面添加的话，它就会new一个新的数组，长度是多少呢，50%延长，长度就是15了。把原来数组中的元素复制到新数组中来，在把新元素添加到后面去。

 

      Vector的特点：

      Vector长度也是10，当你超过10的时候，它是100%延长。

 

枚举(Elements)：jdk1.5出现的

      Vector特有的方法：elements();//返回此向量的组件的枚举。返回值是：Enumeration。继承Enumeration接口。所以Vector特有的方法特有方法也就是枚举。

      Elements(枚举)：枚举就是Vector特有的取出方式。

                 方法：hasMoreElements();    nextElement();

通过上面发现枚举和迭代器很像，又通过API发现这个接口的功能与Iterator接口的功能重复的。可是，Iterator还添加了一个可选的移除操作。也就是说其实枚举和迭代是一样的，但在开发时应先考虑Iterator。

 

枚举类：用来实现限定自定义的类型的取值，可以将取值错误问题在编译时期就暴露出来。定义关键字 enum。

特有方法：

name():返回此枚举常量的名称，在其枚举声明中对其进行声明。

ordinal():返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

static valueOf():返回带指定名称的指定枚举类型的枚举常量。

枚举的构造方法

枚举的构造方法必须是私有的，如果构造方法不私有,那么枚举也就没意义了。因为它本来就是为了限定一个类型范围取值,如果可以在外面创建那么枚举的限定功能也就失去了作用。

带有抽象方法的枚举类

元素直接带{}，在{}中重写抽象方法。

 

为什么要有枚举？

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个。否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

枚举只有一个成员时，就可以作为一种单例的实现方式，在枚举元素后面加上一对括号就表示创建这个元素指向的实例对象是由哪个构造方法。

注意：枚举元素必须位于枚举体中的最开始部分，枚举元素列表后如果有其他成员就要用分号与其他成员分隔,如果没有可以不加分号。如果把枚举中的成员方法或变量等放在枚举元素的前面，编译器会报告错误。

 

那为什么要出Iterator呢？

因为枚举的名称以及方法名称都过长。所以被迭代器取代了。枚举就很少用了。

注：在IO中有一个对象用到了枚举，因为那个对象也是1.0出现的，那时没有迭代只有枚举。

LinkedList(链接列表简称链表  不同步)

LinkedList特有方法:

           addFirst();//添加头部  输出结果是倒着的

           addLast();

           getFirst();//取头

           getLast();//取尾

                获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException（没有这个元素异常）

           removeFirst();

           removeLast();

                获取元素，但元素被删除。如果集合中没有元素，会出现NoSuchElementException。

在JDK1.6出现了替代方法

           offerFirst();

           offerLast();

                添加元素。

           peekFirst();

           peekLast();

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

           pollFirst();

           pollLast();

               获取元素，但元素被删除。如果集合中没有元素，会返回null。

LinkedList示例：

/*使用LinkedList模拟一个堆栈或者队列数据结构。堆栈：先进后出  如同一个杯子。队列：先进先出 FIFO 如同一个水管。*/import java.util.*;class DuiLie{private LinkedList link;DuiLie()//初始化{link = new LinkedList();//一初始化就有LinkedList}public void myAdd(Object obj)//添加元素{link.addFirst(obj);}public Object myGet()//获取元素{return link.removeFirst();//removeFirst()是堆栈removeLast()是队列}public boolean isNull()//判断是否为空{return link.isEmpty();}}class  LinkedListTest{public static void main(String[] args) {DuiLie dl = new DuiLie();dl.myAdd("java01");dl.myAdd("java02");dl.myAdd("java03");dl.myAdd("java04");while(!dl.isNull()){System.out.println(dl.myGet());}}}

ArrayList示例：

import java.util.*;/*将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。思路：1，对人描述，将数据封装进人对象。2，定义容器，将人存入。3，取出。*/class ArrayListTest2 {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {ArrayList al = new ArrayList();al.add(new Person1("lisi01",30));//添加元素al.add(new Person1("lisi02",32));al.add(new Person1("lisi02",32));al.add(new Person1("lisi04",33));al = singleElement(al);//调用去重复方法for(Iterator it = al.iterator();it.hasNext();)//遍历集合{Person1 p = (Person1)it.next();//强转sop(p.getName()+"::"+p.getAge());}}public static ArrayList singleElement(ArrayList al)//去除重复元素{//定义一个临时容器。ArrayList newAl = new ArrayList();for(Iterator it = al.iterator();it.hasNext();){Object obj = it.next();if(!newAl.contains(obj))newAl.add(obj);}return newAl;}}class Person1{private String name;private int age;Person1(String name,int age){this.name = name;this.age = age;}public boolean equals(Object obj)//覆盖父类中的equals方法，定义自己的比较方法{if(!(obj instanceof Person1))return false;Person1 p = (Person1)obj;//System.out.println(this.name+"....."+p.name);return this.name.equals(p.name) && this.age == p.age;}public String getName(){return name;}public int getAge(){return age;}}

注：发现Set集合的功能和Collection是一致的。

HashSet存储自定义对象示例：

import java.util.*;/*往hashSet集合中存入自定对象姓名和年龄相同为同一个人，重复元素。*/class HashSetTest {public static void sop(Object obj)//定义输出语句方法{System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();//创建HashSet集合hs.add(new Person("a1",11));hs.add(new Person("a1",11));hs.add(new Person("a3",13));//sop("a1:"+hs.contains(new Person("a2",12)));Iterator it = hs.iterator();//创建迭代器while(it.hasNext())//遍历集合{Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}}class Person{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}public int hashCode()//复写hashCode，Set集合先比较哈希值{//System.out.println(this.name+"....hashCode");return name.hashCode()+age*37;//年龄乘一个数是为了保证哈希值的唯一性}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;}}

TreeSet排序的的方式：

                TreeSet排序的第一种方式：让元素自身具备比较性。

                     元素需要实现Comparable接口，覆盖compareTo方法。

                     这种方式也称为元素的自然顺序，或者叫做默认顺序。

                TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

                     怎样让集合自身具备比较性呢？

                     在集合初始化时，就有了比较方式。这就要参阅构造函数。

TreeSet存储自定义对象示例：

import java.util.Iterator;import java.util.TreeSet;/*需求：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。记住，排序时，当主要条件相同时，一定判断一下次要条件。*/class TreeSetDemo {public static void main(String[] args) {TreeSet ts = new TreeSet();//定义TreeSet集合ts.add(new Student("lisi02",22));//添加ts.add(new Student("lisi007",20));ts.add(new Student("lisi09",19));ts.add(new Student("lisi08",19));//ts.add(new Student("lisi007",20));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)//覆盖Comparable中的compareTo方法{//return 1;//如果只有这个，就是怎么存怎么取，-1就是倒序。if(!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s = (Student)obj;//强转//System.out.println(this.name+"....compareto....."+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;}}

 

在这里会抛一个异常：ClassCastException:类型转换异常。

 

Comparable:此接口强行对实现它的每个类的对象进行整体排序。

compareTo方法也叫自然比较方法。

 

TreeSet的底层数据结构是二叉树。

二叉树好处：可以减少比较次数，提高比较性能。它在元素多的时候会自动取一个折中值比较。

二叉树是怎么取值的呢？

它是从小到大取，是默认顺序。二叉树的左边是小的，右面是大的。

 

Comparator(比较器)：TreeSet排序的第二种方式。

TreeSet(Comparator<? Super E> comparator):构造一个新的空TreeSet,它根据指定比较器进行排序。

示例：

import java.util.*;/*当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。同样以return 0;判断是否相同。*/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){if(!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s = (Student)obj;//System.out.println(this.name+"....compareto....."+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;}}class TreeSetDemo2 {public static void main(String[] args) {TreeSet ts = new TreeSet(new MyCompare());//按比较器排序    把Comparator接口的子类对象传进来ts.add(new Student("lisi06",22));ts.add(new Student("lisi08",21));ts.add(new Student("lisi08",20));ts.add(new Student("lisi02",19));ts.add(new Student("lisi01",18));ts.add(new Student("lisi01",19));ts.add(new Student("lisi07",29));for(Iterator it = ts.iterator();it.hasNext();)//遍历集合{Student stu = (Student)it.next();System.out.println(stu.getName()+"..."+stu.getAge());}}}class MyCompare implements Comparator{public int compare(Object o1,Object o2){Student s1 = (Student)o1;Student s2 = (Student)o2;int num = s1.getName().compareTo(s2.getName());if(num==0){//return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));return s1.getAge()-s2.getAge();}return num;}}

TreeSet练习代码示例：

/*"90 -7 0 18 2 45 4"将字符串中的数值进行排序。使用TreeSet完成。思路1，将字符串切割。2，可以将这些对象存入TreeSet集合。因为TreeSet自身具备排序功能。*/import java.util.*;class TreeSetTest2 {public static void main(String[] args) {String str = "90 -7 0 18 2 45 4";String[] arr = str.split(" ");TreeSet ts = new TreeSet();for(int x=0; x<arr.length; x++){//ts.add(new Integer(arr[x]));ts.add(Integer.parseInt(arr[x]));}System.out.println(ts);}}

泛型：详见javaAPI-集合框架(泛型)。

Map集合

Map概述

Map和Collection一样，都可以属于集合框架中的顶层接口，它们两者之间没有外观的必然联系，但内部是有联系的。Map叫双列集合，Collection叫单列集合。

Map集合的特点

                       该集合存储键值对。是一对一对往里存，而且要保证键的唯一性。

Map接口的共性方法

1.添加

      put(K key,V value)

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

2.删除

      clear()

      remove(Object key)

3.判断

      containsKey(Object key)

      containsValue(Object value)

      isEmpty()

4.获取

      get(Object key)

      size()

      values()

      entrySet()

      keySet()

Map的子类对象

   Map

          |--Hashtable:底层是哈希表数据结构，不可以存入null健null值。1.0版，该集合是线程同步的，效率低。

                 |--HashMap:底层是哈希表数据结构，可以存入null健null值。该集合线程不同步，效率高。

                 |--TreeMap:底层是二叉树数据结构，线程不同步。可以用于给map集合中的健进行排序。

Map方法代码示例：

import java.util.*;class  MapDemo{public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();//添加元素，如果在添加时，在put里存入了相同的键。那么后添加的值会覆盖原有键对应值。并且put方法会返回被覆盖的值。System.out.println("put:"+map.put("01","zhangsan1"));System.out.println("put:"+map.put("01","wnagwu"));map.put("02","zhangsan2");map.put("03","zhangsan3");System.out.println("containsKey:"+map.containsKey("022"));//System.out.println("remove:"+map.remove("02"));System.out.println("get:"+map.get("023"));map.put("04",null);System.out.println("get:"+map.get("04"));//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。//获取map集合中所有的值。Collection<String> coll = map.values();System.out.println(coll);System.out.println(map);}}

Map集合的两种取出方式：

Map集合的取出原理：将map集合转成set集合，在通过迭代器取出。

1.Set<k> keyset方法：

将map中所有的键存入到Set集合。因为set集合具备迭代器。所以可以通过迭代方式取出所有的键，在根据get方法，获取每一个键对应的值。

keySet方法示例：

import java.util.*;class MapDemo {public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();map.put("02","zhangsan2");map.put("03","zhangsan3");map.put("01","zhangsan1");map.put("04","zhangsan4");//先获取map集合的所有键的Set集合,keySet();Set<String> keySet = map.keySet();//有了Set集合。就可以获取其迭代器。Iterator<String> it = keySet.iterator();while(it.hasNext()){String key = it.next();//有了键可以通过map集合的get方法获取其对应的值。String value  = map.get(key);System.out.println("key:"+key+",value:"+value);}}}

2.Set<Map.Entry<k,v>> entrySet方法：

将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是：Map.Entry。

entrySet方法代码示例：

import java.util.*;class MapDemo{public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();map.put("02","zhangsan2");map.put("03","zhangsan3");map.put("01","zhangsan1");map.put("04","zhangsan4");//将Map集合中的映射关系取出。存入到Set集合中。Set<Map.Entry<String,String>> entrySet = map.entrySet();Iterator<Map.Entry<String,String>> it = entrySet.iterator();while(it.hasNext()){Map.Entry<String,String> me = it.next();String key = me.getKey();String value = me.getValue();System.out.println(key+":"+value);}}}

       Map.Entry接口：其实Entry也是一个接口，它是Map接口中的一个内部接口。

                              Entry是Map中的一个static内部接口，Entry由HashMap的内部类实现的。

为什么要把Entry定义在Map内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

什么时候使用map集合呢？

当数据之间存在着映射关系时，就要先想到map集合。

TreeMap代码示例：

/*练习："sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择map集合。因为map集合中存放就是映射关系。思路：1，将字符串转换成字符数组。因为要对每一个字母进行操作。2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。3，遍历字符数组。将每一个字母作为键去查map集合。如果返回null，将该字母和1存入到map集合中。如果返回不是null，说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。4，将map集合中的数据变成指定的字符串形式返回。*/import java.util.*;class  MapTest{public static void main(String[] args) {String s= charCount("ak+abAf1c,dCkaAbc-defa");System.out.println(s);}public static String charCount(String str){char[] chs = str.toCharArray();TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();int count = 0;for(int x=0; x<chs.length; x++){if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))continue;Integer value = tm.get(chs[x]);//方法一if(value!=null)count = value;count++;tm.put(chs[x],count);count = 0;/*//方法二if(value==null){tm.put(chs[x],1);}else{value = value + 1;tm.put(chs[x],value);}*/}StringBuilder sb = new StringBuilder();Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();while(it.hasNext()){Map.Entry<Character,Integer> me = it.next();Character ch = me.getKey();Integer value = me.getValue();sb.append(ch+"("+value+")");}return sb.toString();}}

集合框架工具类

Collections

集合框架的工具类，里面定义的都是静态方法。他没有构造函数，是不需要创建对象的。因为它的对象并未封装特有数据，都是共性的。

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

              它有两个常用的子接口:

              List：对元素都有定义索引。有序的。可以重复元素。

              Set：不可以重复元素。无序。

 

Collections是集合框架中的一个工具类。该类中的方法都是静态的

              提供的方法中有可以对list集合进行排序，二分查找等方法。

              通常常用的集合都是线程不安全的。因为要提高效率。

              如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

Collections里比较常用方法：

       1.sort(List<T> list):根据元素的自然顺序对指定列表按升序进行排序。

      2.max(Collection<? extends T> coll):比较最大值，根据元素的自然顺序，返回给定collection的最大元素。

              sort,max方法也可以根据你自己定义的比较器，进行排序或取对最大值。都有泛型的限定。

      3.binarySearch(List<? extends Comparable<? super T>> list,T key):使用二分搜索法搜索指定列表，以获得指定对象。但凡用binarySearch都是有序集合。

              如果元素不具备比较性或不是所需要的，binarySearch方法也可以自己定义的比较器。

      4.fill(List<? super T> list,T obj):使用指定元素替换指定列表中的所有元素。

                  如：List<String> list = new ArrayList<String>();Collections.fill(list,"aa");//将集合中的元素都替换成aa

      5.replaceAll(list,"",""):替换

      6.reverse(list)：反转指定列表中元素的顺序。它用的就是swap()方法。

      7.reverseOrder()：返回一个比较器，它强行逆转实现了Comparable接口的对象collection的自然顺序。

                 也可以强行逆转一个自定义的比较器。

      8.swap(List<?> list,int i,int j):在指定列表的指定位置处交换元素。

      9.shuffle():对列表位置进行随机置换。

      10.synchronizedList(List<T> list):返回指定列表支持的同步列表。

Arrays

用于操作数组的工具类，里面都是静态方法。

Arrays里的一些方法：

        1.asList():返回一个受指定数组支持的固定大小的列表。将数组变成list集合。

        2.equals():比较的是两个数组中内容是否相同。

       3.fill():替换数组里的值。可以指定替换范围。

       4.sort()：对数组进行排序，还可以局部排序。

把数组变成list集合有什么好处呢？

可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。还可以使用subList(),indexOf(),get(),contains()...。如果你增删了会发UnsupportedOperationException(不支持的操作异常)。

集合变数组：用Collection接口中的toArray方法。可以传指定类型的数组。

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

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

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

         所以创建一个刚刚好的数组最优。定义数组长度就用.size();

为什么要将集合变成数组呢？

为了限定对元素的操作，不需要进行增删。

JDK1.5新特性

       1.5版本Collection继承了的一个接口，就是Iterable，可迭代的一个接口。

      Map集合没有继承这个接口说明Map集合里没有迭代器，这个接口的出现就是将迭代方法抽取出来。

这个接口的出现有什么好处呢？

它不光是把这个方法抽离出来提高了集合框架的扩展性。还给集合框架提供了一个新功能，就是高级for循环(foreach)。

高级for循环

格式：for(数据类型变量名：被遍历的集合(Collection)或者数组){}

底层原理：它的底层原理其实还是迭代器，这个升级是简化了书写。

弊端：对集合进行遍历，只能获取集合元素，但不能对集合进行操作。

与迭代器的区别：迭代器除了遍历，还可以进行remove集合中元素的动作。如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。所以建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

 

可变参数

方法的可变参数：只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。

示例：

class ParamMethodDemo{public static void main(String[] args) {show("haha",2,3,4,5,6);}public static void show(String str,int... arr)//( int... arr, String str)这个不可以{System.out.println(arr.length);}}

注意：使用时可变参数一定要定义在参数列表最后面。

StaticImport:静态导入

示例：

import java.util.*;import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。import static java.util.Collections.*;import static  java.lang.System.*;//导入了System类中所有静态成员。class  StaticImport {public static void main(String[] args) {out.println("haha");int[] arr = {3,1,5};sort(arr);//省略了这个方法前面的Arrays.int index = binarySearch(arr,1);out.println(Arrays.toString(arr));out.println("Index="+index);ArrayList al = new ArrayList();al.add(1);al.add(3);al.add(2);out.println(al);sort(al);out.println(al);}}

为什么不能去掉System.out.println(Arrays.toString());中的Arrays.呢？

因为类本身都继承了Object类，Object类里也有toString方法，它就认为是Object类里的toString方法。就会出异常。

注意：1.当类名重名时，需要指定具体的包名。2.当方法重名时，指定具备所属的对象或者类。

静态导入的原则：

                             1.正确格式是：import static 错误格式：static import

                             2.不要用含糊不清的命名static成员。

                                           如：如果对Integer类和Long类执行静态导入，引用MAX_VALUE将导致一个编译器错误，因为Integer和Long都有一个MAX_VALUE常量，Java不会知道你在引用哪个MAX_VALUE。

                            3.你可以在静态对象引用、常量(是static或final的)和静态方法上进行静态导入。

注意：如果不是静态导入，导入的都是类。静态导入后导入的是某一个类中所有的静态成员。

API其他对象

System对象

      System类包含一些有用的类字段和方法。它不能被实例化。这说明对象没有提供构造函数。

      System:类中的方法和属性都是静态的。

                          out:标准输出，默认是控制台。in:标准输入，默认是键盘。

          currentTimeMillis():返回以毫秒为单位的当前时间。

           exit(int status):终止当前正在运行的 Java虚拟机。

      获取系统属性信息：Properties getProperties();

      System.getProperty():确定当前的系统属性。可以在jvm启动时，动态加载一些属性信息。因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。那么可以通过map的方法取出该集合中的元素。该集合中存储都是字符串,没有泛型定义。

Runtime对象

Runtime:每个java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。

该类并没有提供构造函数,说明不可以new对象。发现该类中还有非静态方法,说明该类肯定会提供方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式完成，保证了对象的唯一性。

      该方法是static Runtime getRuntime();。Runtime r = Runtime.getRuntime();

Process exec():在单独的进程中执行指定的字符串命令。

Date对象

这是一个日期类。类Date表示特定的瞬间，精确到毫秒。

DateFormat类:日期格式化,这是一个抽象类。

SimpleDateFormat：是DateFormat的子类。

 

自定义格式：

                      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

                       sdf.format(new Date());

Calendar对象

获取单个年月日。如：Calendar c = Calendar.getInstance();              c.get(Calendar. YEAR);//获取年

Math类

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

方法：

             Math.ceil(12.546);//返回大于指定数据的最小整数。

             floor();//返回小于指定数据的最大整数。

             round(1.32);//四舍五入

             pow(3,5);//3的5次方

             random();//返回一个伪随机double值，大于等于0.0且小于1.0

Random类

此类的实例用于生成伪随机数流。可以用random方法也可以用Random类。

 

总结：

      集合中排序时，当主要条件相同时，一定判断一下次要条件。

      二叉树都是以return 0;来判断是否相同。

      Set集合底层就是使用了Map集合。接口中可以定义内部接口，加static的接口一定是内部接口，因为只有接口在成员位置上才能加静态修饰符。

        集合中只要是哈希表数据结构的就要覆盖hashCode方法与equals方法。

        如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

       map集合被使用是因为具备映射关系。而且有一对多映射，是用到了循环嵌套形式。

       ArrayList取元素有两种方式：1.迭代 2.for循环,get(),就是按角标取。

       Set只有一种：就是迭代器。

        高级for循环这个循环是有局限性的，它只能对集合中的元素进行取出，而不能做修改动作。凡是支持迭代器的集合都支持高级for。

        如果一个类有可能产生N多对象，就让它产生一个自然顺序，实现Comparable接口。如果想自己定义顺序就可以用比较器。

       HashSet比较是先依赖hashcode，之后是equals。

        最常用的集合对象是ArrayList,LinkedList,HashSet,HashMap。

        如果需求里取出元素很多，里面涉及到了频繁的增删操作时用LinkedList。涉及到了增删操作，但不频繁用ArrayList或LinkedList。涉及到了增删，同时用涉及到了查询用ArrayList。如果需求里取出元素不是很多，用ArrayList也是可以的，但是有点慢。

        集合中存放的不是对象实体，放的是对象的内存地址值。数组也是，放的是地址。