Java高级部分--集合

Posted 2020-09-09

一.集合类

Java中数组与集合的比较
1.数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
2.数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象

 

Java中集合框架层次结构

Collection接口

1.一组称为元素的对象

2.一个Collection中可以放不同
类型的数据
1.是Set接口和List接口的父类
2.是否有特定的顺序以及是否允许重复，取决于它的实现

3.Set － 无序的集合；不允许重复  如：HashSet
4.List － 有序的集合；允许重复  如：ArrayList,LinkedList

Set接口
1.Collection的子接口
2.用来包含一组 无序无重复 的对象
3.无序-----是指元素存入顺序和集合内存储的顺序不同
4.无重复------两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复

Set接口的实现类 
1.HashSet-----HashSet的特性在于其内部对象的散列存取，即采用哈希技术
2.TreeSet-----TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的

List接口

1.Collection的子接口
2.用来包含一组 有序有重复 的对象
3.List中的元素都对应一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素
4.List有两种主要的集合实现类：ArrayList,LinkedList

List接口的实现类
1.ArrayList是线性顺序存储的，是一种线性表
2.它的特性和数组很接近，数组大小是不变的，而ArrayList的大小是可以动态改变的

3.LinkedList最主要的功能方面的增强是可以在List的头部和尾部添加、删除、取得元素，直接提供了这些方法的实现

ArrayList与LinkedList的比较
　　存储结构
1.ArrayList是线性顺序存储
2.LinkedList对象间彼此串连起来的一个链表
　　操作性能
1.ArrayList适合随机查询的场合
2.LinkedList元素的插入和删除操作性高

Map接口
1.Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象
2.Map是不同于Collection的另外一种集合接口
3.Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
　　Map接口有两个实现：
1.HashMap — key/value对是按照Hash算法存储的
2.TreeMap — key/value对是排序(按key排序)存储的

HashMap与TreeMap的比较
1.HashMap基于哈希表实现
2.TreeMap基于树实现
3.HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用
4.TreeMap没有调优选项，因为该树总处于平衡状态
5.HashMap性能优于TreeMap

Iterator接口
1.Iterator对象称作迭代器，用来方便的实现对容器内的元素进行遍历操作
2.所有实现了Collection接口的集合类都有一个iterator( )方法，返回一个实现了Iterator接口的对象
3.Iterator对象实现了统一的一个用来遍历Collection中对象的方法
4.Iterator是为遍历而设计，能够从集合中取出元素和删除元素，但是没有添加元素的功能
5.Iterator的功能上比较简单，使用中，只能单向移动

hasNext方法

用来判断指针右边是否还有数据

Next方法

将指针向右移动一次，将划过的数据取出来

Iterator<String>    iter=hs1.iterator();
           while(iter.hasNext()){
       System.out.println( iter.next());
　　}

如何选择集合类
1.Set内存放的元素不允许重复，List存放的元素有一定的顺序
2.Map的应用主要在利用键/值对进行快速查询
3.ArrayList和LinkedList的区别在于随机查询性能上ArrayList要好，但LinkedList的中间元素的插入与删除性能好 
4.HashSet和TreeSet的区别在于集合内元素是否排序 

 

 

collection接口

 1 package util1;
 2 
 3 import java.util.Collection;
 4 import java.util.HashSet;
 5 
 6 public class Collection1 {
 7 
 8     /**
 9      * @param args
10      */
11     public static void main(String[] args) {
12         
13         //实例化对象
14         Collection   c1=new HashSet();   //向上转型---  声明成接口类型，调用实现类的构造方法
15         Collection   c2=new HashSet(); 
16          //添加数据
17         c1.add(1);
18         c1.add("你");
19         c1.add(new  A());  
20         
21         System.out.println(c1);    //整体取出数据：直接输出集合名称  
22         
23         c2.addAll(c1);   //添加其他集合
24         System.out.println(c2.size());    //取集合长度
25         System.out.println(c2.contains("sgtht"));   //判断是否包含某些数据
26         
27         System.out.println("///////////////");   
28        Object  o[]    =c2.toArray();    //将集合转换成数组
29        /*for(int i=0;i<o.length;i++){
30            System.out.println(o[i]);
31        }*/
32        
33          System.out.println(o[0]);
34          System.out.println(o[1]);
35          System.out.println(o[2]);
36        
37         
38     }
39 
40 }

set集合

hashSet,treeSet

 1 package util1;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 import java.util.TreeSet;
 6 
 7 public class HashSet1 {
 8 
 9     /**
10      * set接口的特点(集合)
11      *     hashset:   无顺序,数据不能重复,长度可扩展
12      *     treeset:  按照自然顺序排列数据，数据不能重复,能够比较大小
13      * 
14      */
15     public static void main(String[] args) {
16         
17           HashSet<String>   hs1=new HashSet<String>();
18           hs1.add("a");
19           hs1.add("b");
20           hs1.add("b");
21           hs1.add("c");
22 /*          System.out.println(hs1);  
23           
24           //挨个取出集合中的数据
25          Iterator<String>    iter=hs1.iterator();
26           while(iter.hasNext()){
27              System.out.println( iter.next());
28           }
29           */
30           
31           
32             TreeSet<Integer>   ts1=new TreeSet<Integer>();
33             ts1.add(1);
34             ts1.add(768);
35             ts1.add(43);
36             ts1.add(43);
37             ts1.add(87);
38             System.out.println(ts1); 
39             
40             
41           //类型转换异常
42             
43             TreeSet  ts2=new TreeSet();
44             ts2.add("adsf");
45             ts2.add("u11");    
46             ts2.add("caa");
47             System.out.println(ts2);  
48     }
49 
50 }

list集合

linkedList

 1 package util1;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 import java.util.LinkedList;
 6 
 7 public class List1 {
 8 
 9     /**
10      *    list（列表）:   下标从0开始
11      *        
12      *          linkedList:  方便首尾操作 ，    数据可重复,有顺序,长度可扩展
13      *          ArrayList:(数组列表)  :   数据可重复,有顺序,长度可扩展
14      * 
15      */
16     public static void main(String[] args) {
17        
18         LinkedList<Integer>   ll=new LinkedList<Integer>();
19         ll.add(1);
20         ll.add(454);
21         ll.add(454);
22         ll.add(454);
23         ll.add(454);
24         ll.add(242);
25         ll.add(0, 88);
26         //ll.add(10, 77);
27         System.out.println(ll);  
28         ll.addFirst(66);
29         System.out.println(ll);
30         System.out.println(ll.get(4));    //按照下标取数据
31         
32         System.out.println("///////////////////");  
33     
34         for(int i=0;i<ll.size();i++){
35             System.out.println(ll.get(i));             
36         }
37         
38         System.out.println("///////////////////");  
39         
40         Iterator<Integer>  it=ll.iterator();
41         while(it.hasNext()){
42             System.out.println(it.next());          
43         }
44         
45         System.out.println("///////////////////");  
46         //foreach循环,增强的for循环------提高效率(封装了迭代器)
47           for(Integer   in:ll){
48               System.out.println(in);
49           }
50   
51     }
52 
53 }

map接口

hashmap集合

 1 package util1;
 2 
 3 import java.util.HashMap;
 4 import java.util.Iterator;
 5 import java.util.Map;
 6 import java.util.Set;
 7 import java.util.Map.Entry;
 8 
 9 public class Map1 {
10 
11     /**
12      * map:数据成对存放
13      *     HashMap:  无序存放     key值不能重复，如果key值重复，会替换掉原来的键值对
14      * 
15      * 
16      */
17     public static void main(String[] args) {
18         //声明键值对容器
19         HashMap  hm1=new HashMap<String, String>();
20        
21         hm1.put("1", "a");  
22         hm1.put("2", "b");
23         hm1.put("2", null);  
24         hm1.put("3", "c");
25       System.out.println(hm1); 
26         
27         Set  keys=hm1.keySet();   //将所有key值取出组合成一个set集合
28       /*   Iterator<String>   it=keys.iterator();
29           while(it.hasNext()){                  //循环所有key值
30         //    System.out.println(hm1.get(it.next()));      //根据key值获取value值              
31           }*/
32         
33         
34         Map<String, String>  m1=new HashMap<String, String>();   
35         //向上转型:  节省内存   ,可用接口中的方法，实现类重写的方法,不能用实现类独有的方法
36           m1.put("1", "a");  
37           m1.put("2", "b");
38           m1.put("2", "c");  
39           m1.put("3", "c");
40           System.out.println(m1);
41           
42           Set<Map.Entry<String, String>>  ens=m1.entrySet();   
43           for(Entry<String, String>  e:ens){
44                System.out.println(e.getKey());  
45                System.out.println(e.getValue());  
46           }
47           
48     }
49 
50 }

treemap集合

 1 package util1;
 2 
 3 import java.util.TreeMap;
 4 
 5 public class TreeMap1 {
 6 
 7     /**
 8      *   treemap:   按照key值的自然顺序排列数据,要求key值可以比较大小
 9      */
10     public static void main(String[] args) {
11         
12            TreeMap   tm1=new TreeMap<Integer, String>();
13            tm1.put(44, "gf");
14            tm1.put(4654, "gf");
15            tm1.put(42, "gf");
16            tm1.put(4, "gf");
17            System.out.println(tm1);  
18           System.out.println(tm1.floorKey(5));   //得到小于参数的一个key值
19           System.out.println(tm1.floorEntry(5));  //得到小于参数的一个键值对
20 
21     }
22 
23 }

日期

 1 package util1;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Calendar;
 5 import java.util.Date;   //引包
 6 
 7 public class Date1 {
 8 
 9     
10     public static void main(String[] args) {
11         
12             //当前时间
13             Date   d1=new Date();    //当时的时间
14             System.out.println(d1);  
15             
16             SimpleDateFormat   sdf=new SimpleDateFormat("yyyy年MM月dd日   a hh:mm:ss");
17             String  time1=sdf.format(d1);
18             System.out.println(time1); 
19             
20             
21             //日历类
22            Calendar   c= Calendar.getInstance();  //反转获得时间
23            c.set(2011,11,29);  //自定义的时间
24           System.out.println(c.get(Calendar.YEAR)); 
25 
26     }
27 
28 }