5.09笔记总结

一、List接口的子实现类

        

list接口三个常用的子实现类：ArrayList，Vector和linkedlist

  （1） ArrayList(默认使用此类)

    内部是一种数组实现,查询快,增删慢

    线程不安全,--à不同步-à执行效率高

    遍历功能:

            1)一个是Collection的iterator()

            2)size()和get(int index)普通for循环

   eg：

                //创建集合对象      

1.                  Listlist = new ArrayList()   ;                      
2.   
3.          //创建4个学生对象      
4.   
5.                Students1 = new Student("高圆圆", 27) ;       
6.                Students2 = new Student("赵又廷", 30) ;      
7.                Students3 = new Student("文章", 29) ;        
8.                Students4 = new Student("马伊琍", 39) ;       
9.                  list.add(s1);      
10.                  list.add(s2);      
11.                  list.add(s3);      
12.                  list.add(s4);                     
13.   
14.         //方式1:获取迭代器的方式      
15.   
16.                Iteratorit = list.iterator() ;      
17.   
18.                while(it.hasNext()){      
19.   
20.                      Students = (Student)it.next;                             
21.   
22.                       System.out.println(s.getName()+"---"+s.getAge());      
23.   
24.                }                     
25.   
26.                System.out.println("--------------------------");              
27.   
28.                    
29.   
30.                //方式2:size()和get(intindex)结合: 普通for循环      
31.   
32.                for(intx =0 ;x < list.size() ; x ++) {      
33.   
34.                       Students = (Student)list.get(x) ;      
35.   
36.                       System.out.println(s.getName()+"---"+s.getAge());      
37.   
38.                }      

  

   需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!

   分析：

     1)创建一个旧集合,添加重复元素

     2)创建一个新集合

     3)遍历旧集合中的元素获取到每一个元素

     在旧集合中判断新集合中是否包含旧集合中的元素:包含,不搭理;不包含,添加到新集合中

     4) 遍历新集合

1. //创建一个集合  
2.   ArrayList list = new ArrayList() ;  
3.   
4. //添加元素  
5.   list.add("hello") ;  
6.   list.add("world") ;  
7.   list.add("java") ;  
8.   list.add("hello") ;  
9.   list.add("world") ;  
10.   list.add("hello") ;   
11. 
    
12. //创建一个新的集合  
13.   ArrayList newList = new ArrayList() ;  
14.   
15. //遍历旧集合    
16.   Iterator it = list.iterator() ;    
17.   while(it.hasNext()) {  
18.   String s = (String) it.next() ;  
19.   
20. //判断新集合中是否包含旧集合中的元素  
21.   if(!newList.contains(s)) {  
22.   newList.add(s) ;   
23.   }  
24.   
25. //遍历新集合    
26.   Iterator it2 = newList.iterator() ;    
27.   while(it2.hasNext()) {    
28.   String s = (String) it2.next() ;    
29.   System.out.println(s);  

  （2） Vector:

    底层是一种数组实现,查询快,增删慢

    线程安全的类,同步-à执行效率低

            StringBuffer:线程安全的类

     特有功能:

        1>public void addElement(Object obj)------->add(Object obj)

        2>public Enumeration elements():返回此向量的枚举--->相当于:public Iterator iterator()

        3>boolean hasMoreElements()  --->boolean hasNext() ;

        4>Object nextElement()   --->Object next() ;

      eg:

1. //创建集合对象    
2.      Vector v = new Vector() ;    
3. //添加元素    
4.      v.addElement("hello");    
5.      v.addElement("world");    
6.      v.addElement("java");  
7.   
8. //获取Enumeration :向量的枚举    
9.      Enumeration en = v.elements() ;    
10.      while(en.hasMoreElements()) {    
11.      String s = (String)en.nextElement() ;    
12.      System.out.println(s);  
13.      }

  （3） LinkedList:

    底层是一种链接链表实现,查询慢,增删快,

    线程不安全,不同步-à执行效率高

             特点：元素先进后出

            特有功能:

               a 添加功能:

                  addFirst(Object e):将指定的元素插入到列表的开头

                  addLast(object e):将指定的元素添加到列表末尾

              b 获取功能:

                  getFirst():获取列表第一个元素

                  getLast():获取列表最后一个元素

              c 删除功能

                  public Object removeFirst()移除并返回此列表的第一个元素。

                  public Object removeLast()移除并返回此列表的最后一个元素。

     eg:

1. //创建LinkedList集合对象   
2. LinkedList link = new LinkedList() ;  
3.   
4. //添加元素    
5. link.add("hello");    
6. link.add("world");    
7. link.add("java");    
8. System.out.println("link:"+link);  
9.   
10. //addFirst(Object e):将指定的元素插入到列表的开头    
11. link.addFirst("android");    
12. System.out.println("link:"+link);   
13. link.addLast("mysql");    
14. System.out.println(link);  
15.   
16. //getFirst():获取列表第一个元素  
17.   
18. System.out.println(link.getFirst());    
19. System.out.println(link.getLast());  
20.   
21. //public Object removeFirst()移除并返回此列表的第一个元素。    
22. System.out.println("removeFirst():"+link.removeFirst());    
23. System.out.println(link);  
24.   
25. //public Object removeLast()移除并返回此列表的最后一个元素。    
26. System.out.println(link.removeLast());  

二、泛型：

  问题：使用ArrayList的集合存储元素遍历的时候，按照正常的操作出现了问题，

 泛型：将明确的集合类型的工作推迟到了创建对象或者调用方法的时候，属于一种参数化类型，可以作为参数传递。

  例如：

  // 创建集合对象

   ArrayList <String> array = new ArrayList <String>（）;

  泛型的好处：

   1）将运行时期异常提前到了编译时期

   2）优化了设计，解决了黄色警告线问题

   3）避免了强制类型转换

   (泛型的引出可以提供程序的安全性！)

   泛型的应用：在接口中，类中，方法上应用，在集合中应用最多！

   1> 把泛型定义在类上，提高程序安全性

   2> 泛型是可以在方法上定义的

   3> 接口中泛型，

      //子实现类第一种情况,就是已经知道是什么类型了

      public class InterImpl implements Inter<String> {

@Override
public void show() {
System.out.println("hello");
}

      }
     //第二种情况,就是不知道具体的类型是什么
      public class InterImpl<T> implements Inter<T>{

@Override
public void show() {
System.out.println("hello");
}
      }

  泛型高级（通配符）

     <？>：代表任意类型对象类型，或者任意的Java 类

     <？扩展E>：向下限定，E 的子类或者E 这个类型

     <？super E>：向上限定，E 及其他的父类

三、set

设置集合和列表集合的区别？

  Set集合：注重独一无二的性质,该体系集合可以知道某物是否已近存在于集合中,不会存储重复的元素。用于存储无序(存入和取出的顺序不一          定相同)元素，值不能重复。

  清单：允许元素重复，并且存储特点：有序性（存储和取出一致）

设置常用的子实现类有：HashSet 和TreeSet

  1.HashSet 类

利用设置存储字符串对象：

 HashSet的集合的添加方法底层依赖于双列集合的HashMap，它依赖于两个方法，hashCode（）方法方法和equals（）方法方法，先比较字符串的hashCode（）方法码值一样，再比较的equals（）方法，如果hasCode 码值一样，还要比较内容是否相同，由于存储String，重写了equals（）方法，String 本身重写了equals 方法，所以不需要再重写了！

利用设置存储自定义对象：

由于自定义对象没有重写的equals（）方法和哈希码（）方法，此时需要在自定义的类中重写该方法，才能保证元素的唯一性

  2. TreeSet

既然TreeSet可以自然排序,那么TreeSet必定是有排序规则的。

1):让存入的元素自定义比较规则。

2):给TreeSet指定排序规则。

方式一：元素自身具备比较性

元素自身具备比较性，需要元素实现Comparable接口，重写compareTo方法，也就是让元素自身具备比较性，这种方式叫做元素的自然排序也叫做默认排序。

方式二：容器具备比较性

当元素自身不具备比较性，或者自身具备的比较性不是所需要的。那么此时可以让容器自身具备。需要定义一个类实现接口Comparator，重写compare方法，并将该接口的子类实例对象作为参数传递给TreeMap集合的构造方法。

注意：当Comparable比较方式和Comparator比较方式同时存在时，以Comparator的比较方式为主；

注意：在重写compareTo或者compare方法时，必须要明确比较的主要条件相等时要比较次要条件。（假设姓名和年龄一直的人为相同的人，如果想要对人按照年龄的大小来排序，如果年龄相同的人，需要如何处理？不能直接return 0，因为可能姓名不同（年龄相同姓名不同的人是不同的人）。此时就需要进行次要条件判断（需要判断姓名），只有姓名和年龄同时相等的才可以返回0.）

通过return 0来判断唯一性。