关于JAVA学习

关于JAVA学习_集合

集合:
* 1.存储多个对象，数组、集合
* 2.数组存储对象特点：Student[] stu=new Student[10];
* 一旦创建长度不可变
* 3.集合两大体系:collection和map
* collection接口
* --list
* 有序的,可重复的
* ArraryList:底层就是数组查询速度快,主要实现类
* LinkedList:增删改速度快
* --set接口
* 无序的,不可重复的
* HashSet

collection代码案例:

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Date;
 6 import java.util.Iterator;
 7 
 8 import org.junit.Test;
 9 
10 /**
11  * 集合:
12  * 1.存储多个对象，数组、集合
13  * 2.数组存储对象特点：Student[] stu=new Student[10];
14  *    一旦创建长度不可变
15  * 3.集合两大体系:collection和map
16  *       collection接口
17  *          --list
18  *              有序的,可重复的
19  *              ArraryList:底层就是数组 查询速度快,主要实现类
20  *              LinkedList:增删改速度快
21  *          --set接口
22  *              无序的,不可重复的
23  *              HashSet
24  * 
25  *
26  */
27 public class TestCollection {
28         @Test
29         public void test(){
30             Collection coll=new ArrayList();
31             //1.size();获取集合元素个数
32             System.out.println(coll.size());
33             //add(object obj):添加一个对象
34             coll.add(1);
35             coll.add(17.0);
36             coll.add("哈哈");
37             coll.add(new Date());
38             coll.add("哈哈");
39             System.out.println(coll.size());
40             //3.addAll(collection c):把集合元素从一个添加到另一个
41             //4.isEmpty(): 判断一个集合是否为空,空返回true
42             System.out.println(coll.isEmpty());
43             //5.clear();清除集合中的元素
44             //System.out.println(coll.isEmpty());
45             //6.remove(object o):删除集合中的元素
46             //coll.remove(1);
47             System.out.println(coll.remove(1));
48             //7.removeAll(collection c):从当前集合中删除另一集合中所有元素
49             //8.contains(object o):判断当前集合是否包含集合o
50             //9.toArray():把集合转成一个数组
51             Object [] obs=coll.toArray();
52             for(Object obj:obs){
53                 System.out.println(obj);
54             }
55             
56         }
57         
58         @Test
59         public void test1(){
60             Collection coll = new ArrayList();
61             coll.add("韩信");
62             coll.add("赵云");
63             coll.add("李白");
64             coll.add("玄策");
65             
66             //遍历
67             //迭代 返回一个iterator接口
68             Iterator i=coll.iterator();
69             while(i.hasNext()){  //判断当前元素下面有没有下一个元素
70                 System.out.println(i.next());//指向下一个元素
71             }
72             //foreach
73             for (Object o:coll) {
74                 System.out.println(o);
75             }
76         }
77     
78     
79 }

List接口代码案例:

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 import org.junit.Test;
 8 
 9 public class TestList {
10     @Test
11     public void test(){
12         
13         List list=new ArrayList();
14         //添加元素
15         list.add("123");
16         list.add(12);
17         list.add(1,"添加");  //指定位置
18         System.out.println(list);
19         
20         //根据索引查询
21         System.out.println(list.get(1));
22         
23     }
24     @Test
25     public void test1(){
26         List list=new ArrayList();
27         list.add("孙尚香");
28         list.add("孙悟空");
29         list.add("猪八戒");
30         list.add("张磊");
31         
32         //遍历
33         //第一种for循环
34         for(int i=0;i<list.size();i++){
35             System.out.println(list.get(i));
36         }
37         
38         //第二种foreach
39         for(Object o:list){
40             System.out.println(o);
41         }
42         //第三种 迭代
43         Iterator i=list.iterator();
44         while(i.hasNext()){  //判断当前元素下面有没有下一个元素
45             System.out.println(i.next());//指向下一个元素
46         }
47     }
48 }

set接口代码案例:

 1 package list;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 import java.util.Set;
 6 
 7 import org.xml.sax.HandlerBase;
 8 
 9 /**
10  * set:无序的,不可重复的
11  *   无序:不是随机,值得是元素在底层存储的位置是无序的
12  *   不可重复:在set添加相同元素时,后面的无法添加
13  *   set没有自定义方法
14  * @author ASUS
15  *
16  */
17 public class TextSet {
18 
19     public static void main(String[] args) {
20         Set set=new HashSet();
21         System.out.println(set.size());
22     //添加
23         set.add("张磊");
24         set.add(123);
25         set.add("12.3");
26         set.add(123);
27         System.out.println(set);
28         String str=new String("李四");
29         set.add(str);
30         System.out.println(str.hashCode());
31         
32         //遍历set
33         //第一中:foreach
34         for(Object o:set){
35             System.out.println(o);
36         }
37         //第二种:迭代器
38         Iterator i=set.iterator();
39         while(i.hasNext()){
40             System.out.println(i.next());
41         }
42         
43     }
44 
45 }

Set和List的区别

1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

map接口代码案例:

 1 package map;
 2 
 3 import java.util.Collection;
 4 import java.util.HashMap;
 5 import java.util.Map;
 6 import java.util.Map.Entry;
 7 import java.util.Set;
 8 
 9 import org.junit.Test;
10 
11 /**
12  * map：以key-value的形式进行存储，主要实现类HashMap()
13  *
14  */
15 
16 public class TextMap {
17     
18     @Test
19     public  void test(){
20 //        Object put(Object key,Object value):添加元素到map
21 //        Object remove(Object key)：根据key删除对应的元素
22 //        void putAll(Map t)
23 //        void clear()：清除
24         
25         Map map=new HashMap();
26         //1.添加
27         map.put("1", "张三");
28         map.put(2, "李四");
29         map.put(5, 12.3);
30         map.put("123", 123);
31         /**
32          * key是通过set存储的，不可重复，无序，value是通过collection进行存储的，可重复。
33          * key+value等于一个entry，所entry同等于set，不可重复
34          * 如果添加的时候出现重复，后面的把前面的覆盖了
35          */
36         map.put(5, "王五");
37         System.out.println(map);
38         System.out.println(map.size());
39         map.remove(2);
40         System.out.println(map);
41         
42 //        Object get(Object key):根据key查询对应的value
43 //        boolean containsKey(Object key):判断当前map是否包含指定的key
44 //        boolean containsValue(Object value):判断当前map是否包含指定的value
45 //        int size()
46 //        boolean isEmpty()
47 //        boolean equals(Object obj)
48         
49         System.out.println(map.get(5));
50         System.out.println(map.containsKey(5));
51         System.out.println(map.containsValue("王五"));
52 
53     }
54     
55     @Test
56     public void test1(){
57         Map map=new HashMap();
58         //1.添加
59         map.put("1", "张三");
60         map.put(2, "李四");
61         map.put(5, 12.3);
62         map.put("123", 123);
63         
64 //        Set keySet():遍历所有的key
65 //        Collection values():遍历所有的value
66 //        Set entrySet():遍历所有的entry
67         
68         System.out.println("==============遍历所有的key");
69         Set set=map.keySet();
70         for(Object o:set){
71             System.out.println(o);
72         }
73         
74         System.out.println("============遍历所有的value");
75         Collection coll=map.values();
76         for(Object o:coll)
77         System.out.println(o);
78         
79         //遍历所有的key和value   key:value
80         System.out.println("================");
81         Set set1=map.keySet();
82         for(Object o:set1){
83             System.out.println(o+":"+map.get(o));
84         }
85         
86         System.out.println("=============");
87         Set set2=map.entrySet();
88         for(Object o:set2){
89             //把o转成entry
90             Entry entry=(Entry)o;
91             System.out.println(entry.getKey()+":"+entry.getValue());
92         }
93     }
94 
95 }

泛型:(后续详细学习)

 1 package map;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 /**
 7  * 泛型:指定集合只能添加什么类型的数据
 8  * @author ASUS
 9  *
10  */
11 public class Test {
12 
13     @org.junit.Test
14     public void test(){
15         List<Integer> list=new ArrayList<Integer>();
16         list.add(90);
17         list.add(80);
18         list.add(99);
19         list.add(90);
20         
21         for(int i=0;i<list.size();i++){
22             int score=list.get(i);
23             System.out.println(score);
24         }
25         
26     }
27 }

如何使用迭代器

通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。

一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。

迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。

更多:https://www.runoob.com/java/java-collections.html