JCF---java核心集合框架

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);
	}
}

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内存当中的过程

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

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;
		}
	}
}

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内存布局