java中集合总结

集合

Random r=new Randow();
r.nextInt(); //获取一个在int范围内的随机数

Random r=new Random();
System.out.println(r.nextInt(10)); //nextInt(int a)里面带有参数时，获取一个在10范围内的随机数

object类里面有个方法finalize()

当垃圾收集确定不再有对该对象的引用时，例如：new Demo(),垃圾收集器在对象上调用该对象
一般这个方法是自动调用的，当有足够多的垃圾时就会被调用。
如果我们想要及时去清理垃圾，就可以互喊它去清理垃圾，调用System.gc()这个方法，他只是呼唤去清理垃圾器，运行垃圾回收

System.exit(0),表示退出java虚拟机

System.currentTimeMillis()表示现在离1970年1月1日的毫秒数
利用它我们可以得到程序运行的时间，算出来中间时间差距。

public static void arraycopy(Object src,int srcPos, Object dest,int destPos,int length)
将指定源数组中的数组从指定位置复制到目标数组的指定位置。

BigInteger使存的数据可以更大
BigDecimal可以使存的数据更加的准确，BigDecimal bi=BigDecimal.valueOf(0.9)，结果为0.9

alt+enter可以抛异常。

数组和集合的区别：
1.数组既可以存基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值
集合只能存储引用数据类型（对象）,集合中也可以存储基本数据类型，但是在存储的时候会自动装箱为对象。

2.数组长度是固定的，不能自动增长
集合的长度是可变的，可以根据元素的增长而增长
public static void main(String[] args) {
Student[] stu=new Student[4];
// stu[i]其实就是实例，可以调用类中的方法，属性
//Student student=new Student(“科比”,28,“男”);
stu[0]=new Student(“科比”,28,“男”);
stu[1]=new Student(“詹姆斯”,25,“男”);
stu[2]=new Student(“乔丹”,39,“男”);
stu[3]=new Student();
for (int i = 0; i < stu.length; i++) {
System.out.println(stu[i].getName());
}

集合的内部有的就是数组，只不过，他可以增长，创建原数组的1.5倍，把原来的数组
复制到新数组中，把原来的数组当垃圾丢掉。

collection 接口包括list和set
list：有序的（存和取的顺序一致，有索引，可以存储重复元素）
set：无序的（存和取的顺序不一致，无索引，不可以存储重复元素）

list包括：arraylist(数组实现)，linkedlist(链表实现)，vector(数组实现)
set包括： hashset(哈希算法)，TreeSet(二叉树算法)

list集合特有的一个迭代器，不能用集合对元素进行操作，就会出现并发异常，需要迭代器对对象进行操作

listIterator()方法获取可以增加元素的迭代器
可以在遍历的时候，对元素进行增加操作。
Iterator()方法获取的迭代器，只能够遍历元素，而不能对集合进行增加元素。

记住，继承是全部继承父类的属性和行为。只不过没有被private修饰的可以直接调用

在一个类中创建成员变量然后ArrayList arrayList=new ArrayList();
然后在一个类中进行对象的增删改查，就相当于进行了封装，我们创建类对象，就可以
对里面的对象进行操作。

增强for循环遍历使用：底层依赖的迭代器
//数组的增强for循环
array();
//集合的增强for循环
arraylist();
//自定义的对象进行增强for循环
studentForeach();
}

public static void studentForeach() {
    ArrayList<Student> students = new ArrayList<>();
    students.add(new Student("张先生", 99, 21, "男"));
    students.add(new Student("李小海", 56, 61, "女"));
    students.add(new Student("赵写", 113, 24, "男"));

    for (Student student : students) {
        System.out.println(student);
    }
}

public static void arraylist() {
    ArrayList<String> list = new ArrayList<>();
    list.add("nihap");
    list.add("赠的吗");
    list.add("外");
    list.add("你");
    list.add("李宝玉");
    list.add("而且");
    list.add("服务");
    for (String s : list) {
        System.out.println(s);
    }
}

public static void array() {
    int[] arr={11,23,45,35,64,77,89,144};
    for (int i : arr) {
        System.out.println(i);
    }
}

增强for循环不能删除元素，，因为 它底层是迭代器，会发生并发异常。

方法的参数列表中存在可变参数，public void print（int … arr）{
}

其实…底层就是数组，输入的就是arr数组里面的数，
例如：print(11,22,33,55,15)其实就是将数字赋给数组arr。

接口中定义默认方法主要是对接口方法的拓展，里面是可以有方法体的，使其实现它的类不会出现编译报错
如果定义成抽象方法，其实现类就必须就得重写它。默认方法其实现类可以重写也可以不重写。
接口中定义静态方法主要是为了利用接口名.方法名直接去调用该静态方法。里面是可以有方法体的。

类实现接口也是属于继承的一种，类也会拥有接口中的方法

常量格式为:全部大写，多个单词的时候之间用_隔开，必须进行初始化赋值
一般设置为public static int NUMBER_A=10000;

多态：编译看左边，运行看右边，，，变量赋值是在运行阶段
多态的最重要的应用就是传参，形式参数设置为父类类型。

1. 继承或者实现【二选一】 （类和抽象类和接口都可以做父类类型）
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】

抽象类和接口都可以做父类类型
父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利

记住多态的向上转型（子类对象用父类接收，编译看左边，运行看右边，运行子类重写后的方法）
向下转型（父类对象强转为子类对象，调用子类独有的方法）

接口可以作为方法的参数和返回值
比如:list a=new arraylist();

被final修饰的类不能够继承，被final修饰的方法不能够重写，被final修饰的变量不能够修改

匿名内部类就是为了创建没有名字的子类对象
作用是创建子类对象，下面这个就是创建的子类对象，可以当做参数传进去

里面方法体就是重写父类名或者接口名所有的抽象方法
使用方式
//调用内部类方法
new 父类名或者接口名（）{
//方法重写
@override
public void method(){
//执行语句
}
};

//我们使用一个接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
//接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

接口作为一个类的属性，在该类中肯定用到该接口的方法，然后在测试类中，创建不同的子类对象，也就是
用到了匿名内部类，重写了方法，那么类中所用的方法就改变了。作用就是用重写不同的方法

HashMap和Hashtable的区别：
相同点：
底层都是哈希算法，都是双列集合
不同点：
1.HashMap是线程不安全的，效率高，JDK1.2版本
Hashtable是线程安全的，效率低，JDK1.0版本，相当于list里面vector
2.HashMap可以存储null键和null值。
Hashtable不可以存储null键和null值。（null就是指不存在）

arrays和collections中的binarysearch（排序好被查找的集合，被查找的元素）
返回值为元素的索引 。
如果没有排序，结果是未定义的
如果不存在的话就返回(负的插入点索引) - 1

比较器排序（返回值为正数，放到右边，返回值为负数，放到左边）其实是二叉树进行排序。

Comparable接口：这个接口是需要Javabean去实现的，并且指明其泛型，然后重写compareTo方法，这里面写需要按照什么样的顺序进行排序。
调用者（带this的调用）的属性值-参数列表中为升序排列，反者参数列表中减去调用者（带this的调用）为降序
public int compareTo(Student o) {
//成绩降序，年龄升序
float v = o.getScore() - this.getScore();
return v == 0 ? (this.getAge() - o.getAge()) : (int) v;
}
Comparator接口:这个借口是需要在参数列表中传递其子类对象（一般用匿名对象）然后重写其compare方法,里面两个参数，
参数列表中第一个对象的属性值减去第二个为升序排列，反者参数列表中第二个减去第一个为降序
//成绩降序，年龄升序
public int compare(Student o1, Student o2) {
float v = o2.getScore() - o1.getScore();
return v==0?o1.getAge()-o2.getAge():(int)v;
}
});
线程：

线程调用sleep（5000）方法是不会让出这个锁的，只是这个线程睡眠多久。
Wait(5000)是让出来锁的，其他的线程可以去抢占CPU了。
join()方法是让自己优先执行本线程。

同步锁:
1. 同步代码块
synchronized (锁对象){
需要同步的代码// 同一时间,只有一个线程能执行
}

 2. 同步方法
    1. 语法 : 方法声明 : synchronized +  返回值类型
    2. 同步方法也有锁对象
        1. 普通方法 : this (必须保证当前类对象唯一)
        2. 静态方法 : 当前类.class (Class 对象)  反射里讲

 3. Lock (JDK1.5 之后的 接口) -> ReentrantLock (实现类)
    0. 把操作锁的过程具象化 : 获取锁和释放锁
    1. lock : 获取锁
    2. unlock : 释放锁