黑马程序员——java学习8（166-总结）——集合

 1 import java.util.*;
 2 class  CollectionDemo
 3 {
 4     public static void main(String[] args) 
 5     {
 6         
 7         method_get();
 8 
 9 
10     }
11     public static void method_get()
12     {
13         ArrayList al=new ArrayList();
14         al.add("java1");
15         al.add("java2");
16         al.add("java3");
17         al.add("java4");
18 
19         /*
20         Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素    接口不能创建对象，通过集合的iterator方法，返回迭代器。
21         while(it.hasNext())
22         {
23             sop(it.next);
24         }
25         */
26         for(Iterator it=al.iterator();it.hasNext();)
27         {
28             sop(it.next());
29         }
30 
31     }
32     public static void method_2()
33     {
34         ArrayList al1=new ArrayList();
35         al1.add("java1");
36         al1.add("java2");
37         al1.add("java3");
38         al1.add("java4");
39 
40         ArrayList al2=new ArrayList();
41         al2.add("java1");
42         al2.add("java2");
43         al2.add("java5");
44         al2.add("java6");
45         
46         //al1.retainAll(al2);//取交集，al1中只保留和al2中相同的元素
47         al1.removeAll(al2);//去掉相同，留不同
48         
49         sop("al1:"+al1);
50         sop("al2:"+al2);
51     }
52     public static void base_method()
53     {
54         //创建一个集合容器，使用Collection接口的子类，ArrayList
55         ArrayList al=new ArrayList();
56 
57         //1、添加元素
58         al.add("java1");//add(Object obj)
59         al.add("java2");
60         al.add("java3");
61         al.add("java4");
62 
63         //打印原集合
64         sop("原集合"+al);
65         //3、删除元素
66         //al.remove("java2");
67         //al.clear();清空
68 
69         //4、判断元素
70         sop("java03是否存在："+al.contains("java03"));
71         sop("集合是否为空？"+al.isEmpty());
72         //2、获取个数，集合长度
73         sop("size:"+al.size());
74         //打印改变后的集合
75         sop(al);
76     }
77     public static void sop(Object obj)
78     {
79         System.out.println(obj);
80     }
81 }

 1 package learn;
 2 import java.util.*;
 3 /*
 4  * 枚举就是Vector特有的取出方式
 5  * 发现枚举和迭代器很像，因为枚举的名称以及方法的名称都过长
 6  * 所以被迭代器取代了
 7  * IO中会用到
 8  * */
 9 public class VectorDemo {
10     public static void main(String[] args) {
11         Vector v=new Vector();
12         v.add("java01");
13         v.add("java02");
14         v.add("java03");
15         v.add("java04");
16         
17         Enumeration en=v.elements();
18         
19         while(en.hasMoreElements())
20         {
21             System.out.println(en.nextElement());
22         }
23         
24     }
25 }

 1 package learn;
 2 
 3 import java.util.LinkedList;
 4 
 5 /*
 6  * 使用LinkedList模拟一个堆栈或者队列数据结构
 7  * 堆栈：先进后出，杯子
 8  * 队列：先进先出， first in first out FIFO,水管
 9  * */
10 class Duilie
11 {
12     private LinkedList link;
13     Duilie()
14     {
15         link = new LinkedList();
16     }
17     public void myAdd(Object obj)
18     {
19         link.addFirst(obj);
20     }
21     public Object myGet()
22     {
23         return link.removeLast();
24     }
25     public boolean isNull()
26     {
27         return    link.isEmpty();
28     }
29     
30     
31 }
32 public class LinkedListTest {
33     public static void main(String[] args) {
34         Duilie dl=new Duilie();
35         dl.myAdd("java01");
36         dl.myAdd("java02");
37         dl.myAdd("java03");
38         dl.myAdd("java04");
39         while(!dl.isNull())
40         {
41             System.out.println(dl.myGet());
42         }
43     }
44 }

 1 package learn;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 /*
 7  * 去除ArrayList集合中的重复元素 
 8  * */
 9 public class ArrayListTest {
10     public static void main(String[] args) {
11         ArrayList al=new ArrayList();
12         al.add("java01");
13         al.add("java02");
14         al.add("java01");
15         al.add("java02");
16         al.add("java01");
17 //        al.add("java03");
18         /*
19          * 在迭代器循环中next调用一次，就要hasNext判断一次
20         Iterator it=al.iterator();
21         while(it.hasNext())
22         {
23             sop(it.next()+"..."+it.next());
24         }
25         */
26         sop(al);
27         al=singleElement(al);
28         sop(al);
29         
30     }
31     public static void sop(Object obj)
32     {
33         System.out.println(obj);
34         
35     }
36     public static ArrayList singleElement(ArrayList al)
37     {
38         ArrayList newal=new ArrayList();
39         Iterator it=al.iterator();     //根据传递进来的arraylist创建迭代器，存放如全新的newal
40         while(it.hasNext())
41         {
42             Object obj=it.next();
43             if(!newal.contains(obj))
44             {
45                 newal.add(obj);
46             }
47             
48         }
49         return newal;
50     }
51 }

 1 package learn;
 2 
 3 /*
 4  *将自定义对象作为元素存到ArrayList集合中，并去除重复元素
 5  *比如:存入对象，同姓名，同年龄，视为同一个人，为重复元素 
 6  * */
 7 import java.util.ArrayList;
 8 import java.util.Iterator;
 9 
10 class Person{
11     private String name;
12     private int age;
13     Person(String name,int age)
14     {
15         this.name=name;
16         this.age=age;
17     }
18     //Person的字符串方法
19     public boolean equals(Object obj)
20     {
21         
22         if(!(obj instanceof Person))
23             return false;
24         Person p =(Person)obj;
25         System.out.println(this.name+"..."+p.name);
26         //字符串的equals方法
27         return this.name.equals(p.name)&& this.age==p.age;
28         
29     }
30     public String getName()
31     {
32         return name;
33     }
34     public int getAge()
35     {
36         return age;
37     }
38 }
39 
40 
41 public class ArrayListTest2 {
42     public static void sop(Object obj)
43     {
44         System.out.println(obj);
45     }
46     public static void main(String[] args) {
47         
48     
49         ArrayList al=new ArrayList();
50         al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj=new Person("lisi01",30);
51         al.add(new Person("lisi02",32));
52         al.add(new Person("lisi02",32));
53         al.add(new Person("lisi03",33));
54         al.add(new Person("lisi04",35));
55         al.add(new Person("lisi04",35));
56         
57         al=singleElement(al);
58         sop("remover 03:"+al.remove(new Person("lisi03",33)));
59         Iterator it=al.iterator();
60         while(it.hasNext())
61         {
62 //            Object obj=it.next();
63 //            Person p=(Person)obj;
64             Person p=(Person)it.next();
65             sop(p.getName()+"..."+p.getAge());
66         }
67         
68     }
69     public static ArrayList singleElement(ArrayList al)
70     {
71         //定义一个临时容器
72         ArrayList newal=new ArrayList();
73         Iterator it=al.iterator();     //根据传递进来的arraylist创建迭代器，存放如全新的newal
74         while(it.hasNext())
75         {
76             Object obj=it.next();
77             if(!newal.contains(obj))//contains中含有equals
78             {
79                 newal.add(obj);
80             }
81             
82         }
83         return newal;
84     }
85 }

 1 package learn;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 
 6 //|--Set：无序(存入、取出顺序不一致)，元素不可重复
 7 //        |--HashSet：底层数据结构是哈希表
 8 //        |--HashSet是如何保证元素唯一性
 9             //通过元素的hashCode和equals
10             //若元素HashCode值相同，才会判断equals是否为true
11             //不同则不调
12 //注意，对于判断元素是否存在，以及删除操作，依赖的方法是，元素的hashcode（先）和equals方法
13 //set集合的功能时和Collection一致的
14 public class HashSetDemo {
15     public static void sop(Object obj){
16         System.out.println(obj);
17     }
18     public static void main(String[] args) {
19         //按照地址存进去的
20         HashSet hs = new HashSet();
21         
22         //添加失败
23         sop(hs.add("java01"));    
24         sop(hs.add("java01"));    
25         hs.add("java01");
26         hs.add("java01");
27         hs.add("java02");
28         hs.add("java03");
29         hs.add("java04");
30         Iterator it=hs.iterator();
31         while(it.hasNext())
32         {
33             sop(it.next());
34         }
35     }
36 }

 1 package Test;
 2 import java.util.HashSet;
 3 import java.util.Iterator;
 4 /*
 5  * 往HashSet集合中存入自定义对象，姓名年龄相同视为重复对象
 6  * */
 7 class Person{
 8     private String name;
 9     private int age;
10     Person(String name,int age)
11     {
12         this.name=name;
13         this.age=age;
14     }
15     public int hashCode()
16     {
17         System.out.println(this.name+"...hashCode");
18         return name.hashCode()+age*39;//防止相加后的哈希值相同
19     }
20     //Person的字符串方法
21     public boolean equals(Object obj)
22     {
23         
24         if(!(obj instanceof Person))
25             return false;
26         Person p =(Person)obj;
27         System.out.println(this.name+"...equals..."+p.name);
28         //字符串的equals方法
29         return this.name.equals(p.name)&& this.age==p.age;
30         
31     }
32     public String getName()
33     {
34         return name;
35     }
36     public int getAge()
37     {
38         return age;
39     }
40 }
41 
42 public class HashSetTest {
43     public static void sop(Object obj)
44     {
45         System.out.println(obj);
46     }
47     public static void main(String[] args) {
48         HashSet hs=new HashSet();
49         hs.add(new Person("a1",11));
50         hs.add(new Person("a2",12));
51         hs.add(new Person("a3",13));
52         hs.add(new Person("a2",12));
53 //        hs.add(new Person("a4",14));
54         Iterator it=hs.iterator();
55         while(it.hasNext())
56         {
57             Person p=(Person)it.next();
58             sop(p.getName()+"..."+p.getAge());
59         }
60     }
61 }