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