JCF---java核心集合框架

今天药忘吃喽~ 2022-01-26 06:39 215阅读 0赞

# Java Collections Framework #

**集合**：存放数据的容器 批量的存放数据

#### since JDk1.2 集合体系大规模的提供 ####

在JDk1.0提供了：Vector Hashtable

### JDK内置的接口 ###

Collection																Map
    			[单值对象]																[键值对]
    List					Set				Queue		Deque
    [有序]					[无序]			[JDK1.5]	[JDk1.6]
    [不唯一]					[“唯一”]
    
    						SortedSet
    						[有序]
    						[“唯一”]

#### 集合接口的实现类 ####

##### List接口的实现类 ArrayList #####

import java.util.*;
    //包装类(Wrapper Class) 5.0：自动打包 自动解包
    public class TestArray9{
    	public static class main(String args){
    		//java当中数据类型只有两种：基本数据类型 引用数据类型 
    		//基本数据类型只有一个值占用一块空间 引用数据类型：存放引用的空间--->存放对象的空间
    		//java当中的集合只能允许存放引用类型对象 集合只存放引用的空间
    
    		ArrayList<Integer> list = new ArrayList<>();
    		list.add(new Integer(3));
    		list.add(3);//jdk5.0之前 这行会报错 5.0加入自动打包 自动解包
    		//since 5.0 基本数据类型和他对应的包装类可以直接赋值 直接打包 
    		int num1 = 3;
    		Integer num2 = num1;//5.0之后 自动:Integer num2 = new Integer(num1);
    		//5.0 自动解包
    		Integer num3 = 7;
    		int num4 = num3.intValue();
    
    		/*
    			基本数据类型：	boolean char 		byte short int 		long float double
    			类：			Boolean Character 	Byte Short Integer 	Long Float Double
    		*/
    
    		Boolean data1 = null;
    		boolean data2 = data1;//data1.booleanValue();
    		System.out.println(data1);
    		/*
    			空指针异常,自动解包的过程 null给任何方法都会出现空指针异常
    		*/
    	}
    }
    
    //自定义引用类型
    class A{//引用数据类型 	瓶子
    	private int value；//基本数据类型 	液体
    	public int intValue(){
    		return value;
    	}
    
    }

import java.util.*;
     public class TestArrayList1{
     	public static void mian(String[] ates){
     		//如何创建对象
     		List<Interger> list = new ArrayList<>(23); // 瓶子
     		//向ArrayList当中添加元素：add（）
     		list.add(77);
     		list.add(86);
     		list.add(23);
     		list.add(77);
     		System.out.println(list.size());//data.length
    
     		System.out.println(list);
    
     		//得到集合当中的第几个元素
     		Integer num = list.get(0);
     		System.out.println(num);
    
     		//如何遍历ArrayList
    
     		//1st way:for + [i]
     		for(int i = 0; i < list.size() ; i ++){
     			System.out.println(list.get(i));
     		}
    
     		//2nd way: Inteator迭代器
     		Inertor<Integer> car = list.iterator();
     		while(car.hasNext()){//测试是否还有下一件货物
     			Integer data = car.next();//得到下一件货物
     			System.out.println(data);
     		}
    
     		//3rd way:foreach (jdk 5.0)
     		for(Integer i : list){
     			System.out.println(i);
     		}
    
     	}
     }

import java.util.*;
    import java.lang.reflect.*;
    public class TestArrayList2{
    	public static void mian(String[] args){
    		Class c = Class.forName();
    
    		ArrayList<Integer> list = new ArrayList<>(5);//10
    		list.add(1)
    		list.add(2)
    		list.add(3)
    
    		addAll(list,2,3,4,5);
    	}
    	public static void addAll(List list,Integer ... data){//5.0新特性
    		// ...:0~无穷个Integer data：参数名字 
    
    	}
    }

import java.util.*;
    //ArrayList的remove(Object) 如何找到元素的 如何删除元素的 
    public class TestArrayList3{
    	public static void main(String[] args){
    		ArrayList<Integer> list  =  ArrayList<>();
    		Integer i1 = new Integer(7);
    		Integer i2 = new Integer(7);
    		System.out.println(i1 == i2);//false
    		System.out.println(i1.equals(i2));//true
    
    		//remove完全尊重equals方法 
    		list.add(i1);
    		System.out.println(list.size());//1
    		list.add(i2);
    		System.out.println(list.size());//0
    	}
    }

重写Object方法

@Override
    	public boolean equal(Object obj){
    		System.out.println("ok");
    		if(obj == null) return false;
    		if(!(obj instanceof Teacher)) return false;
    		if(obj == this) return true;
    
    		Teacher t1 = this;//参与比较的第一个老师
    		Teacher t2 = (Teacher)obj;//参与比较的第二个老师
    		return (t1.name.equal(t2.name)) && (t1.age == t2.age);
    	}
    }

**扩容机制**

import java.util.*;
    
    //ArrayList的扩容操作
    //7.0之前 *3/2+1 7.0和8.0 扩容机制 old+（old >> 1） 1.5
    
    public class TestArrayList4{
    	public static void main(String[] args){
    		ArrayList<Integer> list = new ArrayList<>(10);
    
    		//如果已经确定ArrayList最终要存放多少元素 那么最在构造的时候直接指定参数
    
    		for(int i = 0 ; i < 16 ; i ++){
    			list.add(i);//new Integer(i);
    		}
    
    		//在添加元素之后 底层的数组元素个数 未必和实际元素个数相同 所以学会使用list.trimToSize()
    		list.trimToSize();//一开始的时候给15个元素 添加12个 调用这个方法后会调整到12个
    
    		ArrayList<Object> list 5 = new ArrayList<>();
    		list5.ensureCapacity(size);//后期指定数组大小 效率也很高
    
    		Class c = Class.forName("java.util.ArrayList");
    		Field f = c.getDecaredField("elementData");
    		f.setAccessible(true);//反射面前无私有 反射可以破封装
    		Object[] data = (Object[])(f.get(list));
    		System.out.println(data.length);//打印list对象当中那个私有属性elementData
    		//结果：6.0 : 16		7.0 : 22 
    		/*
    			6.0:	10	16	25	38...
    			7.0:	10	15	22	33...
    		*/
    	}
    }

**数组在JVM内存当中的过程**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70]  
当 m1 被调用时,一个新的栈帧(Frame-1)被压入JVM栈中,当然,相关的局部变量也在 Frame-1中创建，比如 i;  
然后 m1调用m2,又有一个新的栈帧(Frame-2)被压入到JVM栈中; m2方法在堆内存中创建了A类的一个对象,此对象的引用保存在 Frame-2的局部变量 a 中. 此时,堆内存和栈内存看起来如下所示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 1]

import java.util.*;
    public static void main(String[] args){
    	List<Integer> list = new ArrayList<> (5);
    	Collections.addAll(list,98,93,42,412,3423,32,13,3);
    	list.stream().filter(e -> e >= 60).sored((Integer i1,Integer i2) -> i2 - i1).forEach(System.out::println);
    }

JCF => Java Collections Framework 
    	Java集合框架	     since JDK1.2
    
    集合：用来存放对象的容器~
    
    			JCF
    
    	Collection		Map
    	[单值类型]		[键值对集合]
    
       List		Set		SortedMap
      [有序]		["唯一"]		[要求主键有序且唯一]
      [不唯一]
    
    		SortedSet
    		[有序]
    		["唯一"]
    
    
    List:
    	ArrayList
    	Vector
    	LinkedList
    	Stack
    
    Set:
    	HashSet
    
    SortedSet:
    	TreeSet	
    
    
    
    
    
    如何创建集合：
    	List<Integer> list = new ArrayList<>();
    如何添加元素：
    	一次添加一个元素: list.add(55);
    	一次添加多个元素: Collections.addAll(list,55,33,22,11,44);
    如何得到元素个数：
    	System.out.println(list.size());
    如何得到第几个元素：
    	System.out.println(list.get(0));
    如何判断是否包含某个元素
    	System.out.println(list.contains(44));
    如何遍历整个集合：
    	1st. 普通的for循环结合get(int) -> 只有List才有get(int)
    	2nd. foreach	since JDK5.0
    	3rd. 迭代器Iterator
    	4th. lambda表达式
    
    
    *: ArrayList和Vector的区别?
      最重要的区别
    	ArrayList同一时间允许多个线程同时进行操作
    		效率较高 但是可能出现并发错误
    				相当于KFC
    
    	Vector同一时间只允许一个线程进行操作 效率较低
    		但是不会出现并发错误		
    				相当于学校食堂
    
    	#: 从JDK5.0开始 Collections.synchronizedList()
    
      其次 它们底层实现的细节不同 扩容机制上
    	ArrayList 6.0及之前
    		x*3/2+1 => 扩容
    	ArrayList 7.0及之后
    		x+(x>>1) => 扩容
    
    	Vector 
    		new Vector(10)		*2
    		new Vector(10,5)	+5
    
      最后 它们出现的版本不同
    	ArrayList since JDK1.2
    	Vector since JDK1.0 集合两大鼻祖之一
    	
    		
    *: ArrayList和LinkedList的区别?
    	数组和链表的区别
    	数组优势在于连续存储 所以查找遍历 随机访问效率很高
    	但是添加删除效率很低
    	
    	链表的优势在于添加删除效率很高
    		但是查找遍历 尤其是随机访问效率很低
    
    
    *: HashMap和Hashtable的区别?
    	同步特性不同
    	HashMap允许多个线程同时进行操作 
    		效率较高 但是可能出现并发错误
    	Hashtable同时只允许一个线程进行操作
    		效率较低 但是不会出现并发错误
    	
    	对于null处理不同
    	HashMap 无论主键还是值 都可以添加null
    		但是由于主键对象要求唯一 只能有一个null
    	Hashtable 无论主键还是值 都不允许添加null
    		否则直接出现空指针异常
    
    	它们底层实现的细节不同
    	HashMap 底层默认分为16个小组 分组组数可以指定
    		但是最终结果一定是2的n次方数
    			&(分组组数-1)
    
    	Hashtable 底层默认分11个小组 分组组数随意指定
    			% 分组组数
    
    	它们出现的版本不同
    	HashMap since JDK1.2
    	Hashtable since JDK1.0 集合两大鼻祖

方法重载:

方法覆盖:

public class TestHashSet2{
    	HashSet<Integer> set = new HashSet<>();
    	Integer num1 = new Integer(777);
    	Integer num2 = new Integer(777);
    	set.add(num1);
    	set.add(num2);
    
    	class Student{
    		String name;
    		int age;
    		public Student(String name,int age){
    			this.name = name;
    			this.age = age;
    		}
    		@Override
    		public boolean equals(Object Obj){
    			if(obj == null )return false;
    			if(!(obj instanceof Student)) return false;
    			if(obj == this)return true;
    			Student s1 = this;
    			Student s2 = (Student obj);
    			return s1.name.euqals(s2.name) && s1.age == s2.age;
    
    		}
    		@Override
    		public int hashCode()//散列分组第一句
    		{
    			retrun name.hashCode()+age;
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 2]  
HashSet删除元素同样三步

/*
    	千万不要在添加元素之后尝试修改HashSet当中参与生成hash码的属性
    	否则会导致很多问题
    	刻舟求剑：Hash已经被刻在船体上了
    	如果一定要去修改 那么完全可以先删除 再修改 再添加
    	
    */
    
    
    public class TestHashSet7{
    	public static void main(String[] args){
    		HashSet<Student> set = new HashSet<> (1,0.5F);
    		Student stu = new Student("Tom", 80);
    		set.add(stu);
    		//Tom过生日 age+1
    		stu.age = 81;
    		System.out.println(set.size());
    		//尝试去删除Tom
    		set.remove(stu);//根本删除不掉Tom
    		set.add(stu);
    		System.out.println(set.size());
    	}
    }

/*
    
    	不要在使用迭代器遍历集合的过程中 对集合（Set）整体进行add() remove()操作 否则会触发并发修改异常
    */
    
    public class TestHashSet8{
    	public static void main(String[] args){
    		HashSet<Integer> set = new HashSet<> (16,0.75F)
    		set.add(77);
    		set.add(55);
    		Interator<Integer> car = set.interator;
    		while(car.hasNext()){
    			Integer num = car.next();
    			if(num > 50){
    				set.remove(num);
    				set.remove();//会直接删除全部
    ;			}
    		}
    	}
    }

**HashSet内存布局**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70]: /images/20220126/5e618774f6484da18afe63d2b0b32546.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 1]: /images/20220126/96e0f8c574124f7eab25c7c7610067d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 2]: /images/20220126/f85071f656b84f2bab60f0c79daf9461.png