疯狂的小鸡仔
疯狂的小鸡仔

Java 集合详解

目录

1.集合体系结构

2.Collection集合

2.1 Collection集合

2.1.1 Collection基本方法

2.1.2 Collection遍历方式

2.1.2.1 迭代器遍历

2.1.2.2 增强for循环

2.1.2.3 Lambda表达式

3.List集合

3.1 List集合的基本方法

3.2 List集合的遍历方式

4.数据结构

4.1 数据结构概述

4.2 常见的数据结构

4.2.1 栈

 4.2.2 队列

 4.2.3 数组

4.2.4 链表

4.2.5 二叉树

4.2.6 二叉查找树

4.2.7 平衡二叉树

4.2.8 红黑树

5.ArrayList集合

6.LinkedList集合

7. 泛型

7.1 泛型可以定义的地方

7.1.1 泛型类

7.1.2 泛型方法

7.1.3 泛型接口

7.2 泛型的继承和通配符

8. Set系列集合

8.1 HashSet

8.2 LinkedHashSet

8.3 TreeSet

1.集合体系结构

Java 集合详解_第1张图片

Java 集合详解_第2张图片

 Java 集合详解_第3张图片

 

2.Collection集合

2.1 Collection集合

Collection：单列集合，每次在添加数据的时候只能添加一个元素

Map：双列集合，每次再添加数据的时候，每次添加的是一对数据

 List系列集合：添加的元素是有序、可重复、有索引

这里的有序指存和取得的顺序一样，存1,2,3。取出来的也是1,2,3。和排序无任何关系。

可重复指集合中的元素可以重复。

有索引，我们可以通过索引获取集合中每一个元素。

Set系列集合：添加的元素是无序，不重复，无索引

无序指存和取得的顺序可能不一样，存1,2,3。取出来的不一定是1,2,3。

不重复指集合中存储的元素不能相同，可以利用这个特性进行元素的数据去重。

无索引指不能通过索引获取Set集合里面的每一个元素。

2.1.1 Collection基本方法

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。

Collection是单列集合的顶层接口，所有方法被List和Set系列集合共享。

方法名称 说明
public boolean add(E e) 把给定的对象添加到当前集合中
public void clear() 清空集合中所有的元素
public boolean remove(E e) 把给定的对象在当前集合中删除
public boolean contains(object obj) 判断当前集合中是否包含给定的对象
public boolean isEmpty() 判断当前集合是否为空
public int size() 返回集合中元素的个数/集合的长度

例如：

import java.util.ArrayList;
import java.util.Collection;

public class Collection_Demo01 {
    public static void main(String[] args) {
/**
 * 注意：Collection是一个接口，我们不能直接创建它的对象
 * 只能创建它的实现类的对象
 * 实现类：ArrayList
 */
        Collection collection = new ArrayList<>();
        //添加元素
        //如果往List系列集合中添加数据，永远返回true，因为List集合中允许元素重复
        //如果往Set集合中添加元素，如果没有该元素，返回true，如果要添加的元素已经存在，返回false
        System.out.println(collection.add("aaa"));//true
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        System.out.println(collection);//[aaa, bbb, ccc, ddd]

        //根据对象删除元素
        //因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除，只能通过元素的对象进行删除。
        //删除成功返回true，失败返回false，（如果要删除的元素不存在）
        System.out.println(collection.remove("ccc"));//true
        System.out.println(collection);//[aaa, bbb, ddd]

        //判断元素是否包含
        //contains底层是依赖equals方法进行判断是否存在的。
        //如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法
        System.out.println(collection.contains("aaa"));//true
        System.out.println(collection.contains("ccc"));//false

        //当前集合是否为空
        System.out.println(collection.isEmpty());//false

        //获取集合长度
        System.out.println(collection.size());//3

        //清空
        collection.clear();
        System.out.println(collection);//[]

        //当前集合是否为空
        System.out.println(collection.isEmpty());//true
    }
}

例2：如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

public class Collection_Demo02 {
    public static void main(String[] args) {
        Collection collstu = new ArrayList<>();
        //创建学生对象
        CollectionStudent stu1 = new CollectionStudent("nn", 5);
        CollectionStudent stu2 = new CollectionStudent("bb", 15);
        CollectionStudent stu3 = new CollectionStudent("pd", 25);

        //学生对象添加到集合中
        collstu.add(stu1);
        collstu.add(stu2);
        collstu.add(stu3);

        //判断集合中某一个学生对象是否包含
        CollectionStudent stu4 = new CollectionStudent("pd", 25);
        //同姓名、年龄就是同一个学生
        //不重写equals方法下面为false，因为object类中equals方法，依赖地址值进行判断。
        System.out.println(collstu.contains(stu4)); //true 因为下面重写了equals方法
    }
}

class CollectionStudent {
    private String name;
    private int age;

    public CollectionStudent() {
    }

    public CollectionStudent(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CollectionStudent that = (CollectionStudent) o;
        return age == that.age && Objects.equals(name, that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

2.1.2 Collection遍历方式

2.1.2.1 迭代器遍历

迭代器在遍历的时候不依赖索引。

迭代器在Java中的类是lterator，迭代器是集合专用的遍历方式

Collection集合获取迭代器

方法名称 说明
Iterator iterator() 返回迭代器对象，默认指向当前集合的0索引

lterator中的常用方法

方法名称 说明
boolean hasNext() 判断当前位置是否有元素，有元素返回true没有元素返回false
E next() 获取当前位置的元素，并将迭代器对象移向下一个位置

注意：
1. 如果当前位置没有元素，强行获取，报错NoSuchElementException（没有这个元素异常）

2. 迭代器遍历完毕，不会复位

3. 循环中只能用一次next方法 
4. 迭代器遍历时，不能用集合的方法进行增加或者删除（不是不能删或增）

例如：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collection_遍历_迭代器 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");
        c.add("ddd");
        c.add("eee");
        c.add("fff");

        //获取迭代器对象
        // 迭代器，不是自己new出来的，而是集合"."出来的
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {// 集合中当前位置还有没有没被遍历的元素
            String str = iterator.next();// 获取当前位置的元素，并将迭代器对象移向下一个位置
            // c.remove(); //报错
            // 不要在迭代的过程中，使用集合.remove(obj)这个操作，如果要删除，用iterator.remove();
            System.out.print(str + " ");//aaa bbb ccc ddd eee fff
        }
        System.out.println();


        //System.out.println(iterator.next());//运行报错 NoSuchElementException
        //因为上面的while方法结束,已经指向了没有元素的位置

        System.out.println(iterator.hasNext());//false    没有元素了
        //迭代器遍历完毕，不会复位,

        System.out.println("-----------------");
        //上面的while方法结束是因为没有下一个了，重写一次不会回去
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.print(str + " "); //无内容输出
        }
        System.out.println();

        System.out.println("--------要想再次输出，用下面这方式，重新获取一次----------");
        iterator = c.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.print(str + " ");//aaa bbb ccc ddd eee fff
        }
    }
}

例：循环中只能用一次next方法 ，迭代器遍历时，不能用集合的方法进行增加或者删除

2.1.2.2 增强for循环

增强for的底层就是迭代器，为了简化迭代器的代码书写的。

它是JDK5之后出现的，其内部原理就是一个Iterator迭代器

所有的单列集合（Collection集合）和数组才能用增强for进行遍历。

格式:

idea快捷方式： 集合的名字.for （c.for）

for(元素的数据类型 变量名 : 数组或者集合){
}

修改增强for中的变量，不会改变集合中原本的数据。

遍历过程中，把集合中的每个数据用第三方变量进行记录，进行修改也仅仅是修改的第三方变量的数据

例如：

import java.util.ArrayList;
import java.util.Collection;

public class Collection_遍历_增强for循环 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");
        c.add("ddd");
        c.add("eee");
        c.add("fff");
        //str就是一个第三方变量，再循环的过程中一次表示集合中的每一个元素
        //idea快捷方式：  集合的名字.for   （c.for）
        for (String str : c) {
            System.out.print(str + " ");//aaa bbb ccc ddd eee fff
            str = "asd"; //遍历过程中，把集合中的每个数据用第三方变量进行记录，进行修改也仅仅是修改的第三方变量的数据
        }
        System.out.println();//换行

        System.out.print(c);//[aaa, bbb, ccc, ddd, eee, fff]

        System.out.println();//换行
        int[] arr = {1, 2, 3, 6, 5, 4, 8, 20, 6, 5, 4};
        for (int a : arr) {
            System.out.print(a + " ");//1 2 3 6 5 4 8 20 6 5 4 
        }
    }
}

2.1.2.3 Lambda表达式

JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式

方法名称 说明
default void forEach(Consumer action): 结合lambda遍历集合

例如：

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class Collection_遍历_Lambda表达式 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");
        c.add("ddd");
        c.add("eee");
        c.add("fff");

        //利用匿名内部类的方式
        //底层原理：方法的底层其实也会自己遍历集合，依次得到每一个元素，把得到的每一个元素，传递给下面的accept方法
        c.forEach(new Consumer() {
            @Override
            //s依次表示集合中每一个数据
            public void accept(String s) {
                System.out.print(s + " ");//aaa bbb ccc ddd eee fff
            }
        });
        System.out.println();//换行
        //Lambda表达式
        //()->{}
        //数据类型可以省略，如果只有一个参数（）可以省略。方法体只有一行{}可以省略，return可以省略，;可以省略
        c.forEach(s -> System.out.print(s + " "));//aaa bbb ccc ddd eee fff 
    }
}

仅仅想遍历，用增强for循环或Lambda表达式，想要删除元素，用迭代器

3.List集合

3.1 List集合的基本方法

特点：

  • 有序:存和取的元素顺序一致
  • 有索引:可以通过索引操作元秦
  • 可重复:存储的元素可以重复

Collection的方法，List都继承了。

List集合因为有索引，所以多了很多索引操作的方法。

方法名称 说明
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
get(int index) 返回指定索引处的元素

例如：


import java.util.ArrayList;
import java.util.List;

public class ListDemo01 {
    public static void main(String[] args) {
        //1.创建集合
        //List也是接口，不能直接创建，创建它的实现类对象
        List list = new ArrayList<>();

        //添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        System.out.println(list);//[aaa, bbb, ccc, ddd]

        //指定位置添加元素,原来的元素依次往后移
        list.add(0, "000");//0索引的位置添加000
        System.out.println(list);//[000, aaa, bbb, ccc, ddd]


        //删除指定索引出元素
        System.out.println(list.remove(0));//删除指定索引处的元素，返回被删除的元素 //000
        System.out.println(list.remove("aaa"));//true 把给定的对象在当前集合中删除
        System.out.println(list);//[bbb, ccc, ddd]

        //修改指定元素
        System.out.println(list.set(0, "111"));//bbb  修改指定索引处的元素，返回被修改的元素
        System.out.println(list);

        //返回指定索引处的元素
        System.out.println(list.get(2));//ddd
    }
}

例：remove删除元素注意事项

import java.util.ArrayList;
import java.util.List;

public class ListDemo02 {
    public static void main(String[] args) {
        //List系列集合中的两个删除的方法
        // 1.直接制除 元素//2.通过索引进行删除

        //1.创建集合并添加元素
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        //删除元素
        list.remove(1);
        System.out.println(list);//[1, 3, 4]
        //因为在调用方法的时候，如果方法出现了重载现象,优先调用，实参跟形参类型一致的那个方法。
        //此时的remove不会自动装箱
        //所以这里的1是根据索引来删除的

        //手动装箱，手动把基本数据类型的2，变成Integer类型
        Integer i = Integer.valueOf(1);
        list.remove(i);
        System.out.println(list); //[3, 4]
    }
}

3.2 List集合的遍历方式

List集合有五种遍历方式：

  1. 迭代器遍历
  2. 列表迭代器遍历
  3. 增强for遍历
  4. Lambda表达式遍历
  5. 普通for循环 (因为List集合存在索引)
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Consumer;

public class List_遍历方式 {
    public static void main(String[] args) {
        //创建集合对象（还是多态的方式）
        List list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");

        //1.迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.print(str + " ");//aaa bbb ccc ddd eee
        }
        System.out.println(); //换行

        //2.增强for遍历
        for (String s : list) {
            //下面的变量s，其实就是一个第三方的变量而已,在循环的过程中，依次表示集合中的每一个元素
            System.out.print(s + " ");//aaa bbb ccc ddd eee
        }
        System.out.println(); //换行

        //3.Lambda表达式遍历
        //内部类方式
        //forEach的底层就是循环遍历
        list.forEach(new Consumer() {
            @Override
            public void accept(String s) {
                System.out.print(s + " ");//aaa bbb ccc ddd eee
            }
        });
        System.out.println(); //换行

        list.forEach(s -> System.out.print(s + " "));//aaa bbb ccc ddd eee
        System.out.println(); //换行

        //4.普通for循环 (因为List集合存在索引)
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");//aaa bbb ccc ddd eee
        }
        System.out.println(); //换行

        //5.列表迭代器遍历
        //ListIterator同样是接口

        ListIterator its = list.listIterator();
        while (its.hasNext()) {
            System.out.print(its.next() + " ");//aaa bbb ccc ddd eee
        }
        System.out.println(); //换行

        //在迭代器的基础上额外添加了一个方法，可以添加元素
        ListIterator its1 = list.listIterator();
        while (its1.hasNext()) {
            String str = its1.next();
            if ("aaa".equals(str)) {
                its1.add("0000");
            }
        }
        System.out.print(list + " ");//[aaa, 0000, bbb, ccc, ddd, eee]
    }
}

4.数据结构

4.1 数据结构概述

数据结构是计算机底层存储、组织数据的方式。

是指数据相互之间是以什么方式排列在一起的。

数据结构是为了更加方便的管理和使用数据需要结合具体的业务场景来进行选择。

4.2 常见的数据结构

8种常见的数据结构：栈、队列、数组、链表、二叉树、二叉查找树、平衡二叉树、红黑树。

4.2.1 栈

栈的特点：后进先出，先进后出（一端开口 栈顶，一段封闭 栈底）

数据进入栈模型的过程称为：压/进栈

数据离开栈模型的过程称为：弹/出栈

可以理解为手枪弹夹，先装进去的子弹，后出来，第一个装进去的子弹，最后打出来，最后装进去的子弹，第一个打出来。

Java 集合详解_第4张图片

Java 集合详解_第5张图片

 4.2.2 队列

队列的特点：先进先出，后进后出（一端开口 后端，一端开头 前端）

数据从后面进入，从前面出去

数据从后端进入队列模型的过程称为:入队列

数据从前端离开队列模型的过程称为:出队列

可以理解为排队买票

Java 集合详解_第6张图片

 4.2.3 数组

查询速度快:查询数据通过地址值和索定位，查询任意数据耗时相同。 (元素在内存中是连续存储的)

删除效率低: 要将原始数据删除同时后面每个数据前移

添加效率极低:添加位置后的每个数据后移，再添加元素。

数组是一种查询快，增删慢的模型

4.2.4 链表

链表中的每个元素我们称为结点

每一个结点都是一个独立的对象，自身就会有一个地址值，表示结点在内存中的位置

结点里面会存储具体的数据，同时还会存储下一个结点的地址值

Java 集合详解_第7张图片

 在链表中第一个被创建出来的结点称为头结点

Java 集合详解_第8张图片

链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。 

链表查询慢，无论查询哪个数据都要从头开始找。

链表增删相对快

链表是一种增删快的模型(对比数组

LinkedList和ArrayList对比

  • LinkedList适合增删、不适合遍历
  • ArrayList不适合增删 、适合遍历

Java 集合详解_第9张图片

栈:后进先出，先进后出。
队列:先进先出，后进后出。
数组:内存连续区域，查询快，增删慢。
链表:元素是游离的，查询慢，首尾操作极快。

4.2.5 二叉树

Java 集合详解_第10张图片

 每一个结点都是一个独立的对象，里面存当前的数据，左子节点的地址值，右子节点的地址值

Java 集合详解_第11张图片

 一个结点没有父节点，或者没有子节点，记为null（上面的22、15、17、19、21、23、25、27、29）这些节点对应的位置记为null

度: 每一个节点的子节点数量。（18、16、20、26、24、28）的度都为2。（15、17、19、21、23、25、27、29）的度为0。

二叉树中，任意节点的度<=2（最多两个分叉）

树高: 树的总层数

根节点：最顶层的节点（上面的树是22）

左子节点: 左下方的节点
右子节点: 右下方的节点

根节点的左子树:蓝色虚线
根节点的右子树: 绿色虚线

Java 集合详解_第12张图片

 

4.2.6 二叉查找树

Java 集合详解_第13张图片

 二又查找树，又称二叉排序树或者二叉搜索树

特点：

每一个节点上最多有两个子节点
任意节点左子树上的值都小于当前节点
任意节点右子树上的值都大于当前节点

数据结构 ( 二又查找树 ) 添加节点的规则:

小的存左边，大的存右边，一样的不存

Java 集合详解_第14张图片

 Java 集合详解_第15张图片

 数据结构 ( 二又查找树 ) 查找节点，比节点小左边找，大就右边找

二叉树遍历方式：前序遍历，中序遍历，后序遍历，层序遍历

Java 集合详解_第16张图片

前序遍历：从根结点开始，然后按照当前结点，左子结点，右子结点的顺序遍历。

Java 集合详解_第17张图片

 

 中序遍历：从最左边的子节点开始，然后按照左子结点，当前结点，右子结点的顺序遍历。

Java 集合详解_第18张图片

 后序遍历：从最左边的子节点开始，然后按照左子结点，右子结点，当前结点的顺序遍历

Java 集合详解_第19张图片

 层序遍历：一层一层的遍历

Java 集合详解_第20张图片 

4.2.7 平衡二叉树

 二叉查找树弊端

按照规则将下列节点添加到二叉查找树中

 Java 集合详解_第21张图片

平衡二叉树 规则:任意节点左右子树高度差不超过1

Java 集合详解_第22张图片

 Java 集合详解_第23张图片

二叉树，二叉查找树，平衡二叉树的演变

最基本的二叉树在存储数据的时候没有规则，所以在查找数据的时候非常麻烦，只能遍历查找，效率非常低。为了解决这个问题，提高查找效率，我们在每次添加数据的时候，都会先进行比较，遵守一个规则，小的存左边，大的存右边，一样的不存，这样形成的一个二叉树，我们称为二叉查找树，二叉查找树在查找效率的时候就比较高了。但这样有可能导致左右子树高度差很大，查找效率一样很低，为了避免这种情况出现，我们就有了平衡二叉树，平衡二叉树中，任意节点左右子树高度差不超过1。

Java 集合详解_第24张图片

平衡二叉树为什么平衡？

旋转机制：规则1:左旋。规则2:右旋

触发时机:当添加一个节点之后，该树不再是一颗平衡二叉树

左旋：

确定支点: 从添加的节点开始，不断的往父节点找不平衡的节点

Java 集合详解_第25张图片

步骤：以不平衡的点作为支点，把支点左旋降级，变成左子节点，晋升原来的右子节点 。

Java 集合详解_第26张图片

Java 集合详解_第27张图片 


步骤： 以不平衡的点作为支点，将根节点的右侧往左拉，原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右子节点

Java 集合详解_第28张图片

右旋：

确定支点: 从添加的节点开始，不断的往父节点找不平衡的节点

Java 集合详解_第29张图片
步骤： 以不平衡的点作为支点，把支点右旋降级，变成右子节点，晋升原来的左子节点

Java 集合详解_第30张图片

 

 Java 集合详解_第31张图片

步骤： 以不平衡的点作为支点，就是将根节点的左侧往右拉，原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点

Java 集合详解_第32张图片

平衡二叉树需要旋转的四种情况：左左、左右、右右、右左

左左：当根节点左子树的左子树有节点插入，导致二叉树不平衡

Java 集合详解_第33张图片

 一次右旋Java 集合详解_第34张图片

 

左右:当根节点左子树的右子树有节点插入，导致二叉树不平衡

Java 集合详解_第35张图片

 一次局部左旋，一次整体右旋

Java 集合详解_第36张图片

 

 右右:当根节点右子树的右子树有节点插入，导致二叉树不平衡

Java 集合详解_第37张图片

一次左旋

 Java 集合详解_第38张图片

右左:当根节点右子树的左子树有节点插入，导致二叉树不平衡 

Java 集合详解_第39张图片

  一次局部右旋，一次整体左旋

Java 集合详解_第40张图片 

  1. 在平衡二叉树中，如何添加节点?
    1. 小的存左边，大的存右边，一样的不存
  2. 在平衡二叉树中，如果查找单个节点?
    1. 从根节点开始，小的左边找，大的右边找
  3. 为什么要旋转?
    1. 普通二叉树和二叉查找树不需要旋转，平衡二叉树才需要旋转
    2. 当添加了一个节点后导致这个树不平衡了，需要旋转让这棵树重新保持平衡
  4. 旋转的触发时机?
    1. 当添加一个节点之后，该树不再是一颗平衡二叉树
  5. 左左是什么意思?如何旋转?
    1.  把新节点添加到根节点左子树的左子树，导致二叉树不平衡
    2. 一次右旋
  6. 左右是什么意思?如何旋转?
    1. 把新节点添加到根节点左子树的右子树，导致二叉树不平衡
    2.   一次局部右旋，一次整体左旋
  7. 右右是什么意思?如何旋转?
    1.  把新节点添加到根节点右子树的右子树，导致二叉树不平衡
    2. 一次左旋
  8. 右左是什么意思?如何旋转?
    1. 把新节点添加到根节点右子树的左子树，导致二叉树不平衡
    2.   一次局部左旋，一次整体右旋

4.2.8 红黑树

红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构

1972年出现，当时被称之为平衡二叉B树。后来，1978年被修改为如今的"红黑树"

它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色，

每一个节点可以是红或者黑，红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的

Java 集合详解_第41张图片

红黑规则

  1. 每一个节点或是红色的，或者是黑色的
  2. 根节点必须是黑色
  3. 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点(Ni)是黑色的
  4. 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
  5. 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点，

红黑树增删改查的性能都很好

以上面6节点为例

Java 集合详解_第42张图片

 Java 集合详解_第43张图片

红黑树添加节点的规则
默认颜色:添加节点默认是红色的(效率高)

以下面三个weili

（添加三个节点，调整两次）

 Java 集合详解_第44张图片

 Java 集合详解_第45张图片

 

如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)

对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点

Java 集合详解_第46张图片

 Java 集合详解_第47张图片

 

如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)

对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点，

Java 集合详解_第48张图片

 

例如：

（添加三个节点，调整一次）

 Java 集合详解_第49张图片

 根节点必须是黑色

Java 集合详解_第50张图片

 Java 集合详解_第51张图片

 Java 集合详解_第52张图片

Java 集合详解_第53张图片

 例如：

 Java 集合详解_第54张图片

 根节点必须是黑色直接变为黑色

Java 集合详解_第55张图片

 Java 集合详解_第56张图片

 不需要任何操作

Java 集合详解_第57张图片

 不需要任何操作

Java 集合详解_第58张图片

 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)

将“父”设为黑色，将“叔叔”设为黑色

Java 集合详解_第59张图片

 将“祖父”设为“红色”

Java 集合详解_第60张图片
如果祖父为根，再将根变回黑色

Java 集合详解_第61张图片
Java 集合详解_第62张图片

 不需要任何操作

 Java 集合详解_第63张图片

 

 如果继续添加

最后为

 

 如果添加的是红15 16

最后为

Java 集合详解_第64张图片

 

每一个节点或是红色的，或者是黑色的

根节点必须是黑色

如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点(Ni)是黑色的

如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)

对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点，

5.ArrayList集合

ArrayList集合底层原理

  1. 利用空参创建的集合，在底层创建一个默认长度为0的数组
  2. 添加第一个元素时，底层会创建一个新的长度为10的数组
  3. 数组存满时，会扩容1.5倍
  4. 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

6.LinkedList集合

底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。

特有方法 说明
public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e) 将指定的元素追加到此列表的末尾
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removeFirst() 从此列表中删除并返回第一个元素
public E removeLast() 从此列表中删除并返回最后一个元素

例如：模拟单向链表

public class Demo01_模拟单向链表 {
	public static void main(String[] args) {
		MyList list = new MyList();
		list.add(3);
		list.add(5);
		list.add(7);
		list.add(9);
		list.add(7);
	}
}

/**
 * 链表类
 */
class MyList {
	Node first;
	// 添加
	public void add(Object data) {
		Node node = new Node();
		node.data = data;
		// 如果还没有头节点
		if (first == null) {
			first = node; // 新添加的节点就是头节点
			return;
		}
		Node temp = first;
		while (temp.next != null) {
			temp = temp.next;
		}
		temp.next = node;
	}
}

/**
 * 节点类
 */
class Node {// 节点
	Object data;// 节点中的数据
	Node next;
}

例如：LinkedList和ArrayList对比



import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.junit.Test;

/**
 * LinkedList
 *	1、双向链表：又有next，又有prev
 *	2、它也是实现了List接口
 *	3、arrayList底层 维护的是一个数组
 *		当add时，是执行 elementData[size++] = e;
 *	4、linkedList底层维护的是 一个链表
 *
 *	5、LinkedList和ArrayList对比：
 *		LinkedList适合增删、不适合遍历
 *		ArrayList不适合增删	、适合遍历
 */
public class Demo02_LinkedList_ArrayList对比 {
	public static void main(String[] args) {
		List list = new LinkedList<>();
		list.add(3);//arrayList.add(3)-->arr[i] = 3;
		list.add(4);
		list.add(5);
	}
	
	@Test
	public void testArrayList01(){
		long a = System.currentTimeMillis();
		List list = new ArrayList<>();
		for (int i = 0; i < 100000; i++) {
			list.add(0, i);//前面加0，是为了让数组中后面的元素，都往后移一位
		}
		long b = System.currentTimeMillis();
		System.out.println(b-a);//405
		System.out.println("-----------遍历fori测试---------------");
		for (int i = 0; i < list.size(); i++) {
			list.get(i);
		}
		long c = System.currentTimeMillis();
		System.out.println(c-b);//2
		System.out.println("-----------遍历foreach测试---------------");
		for (Integer i:list) {}
		long d = System.currentTimeMillis();
		System.out.println(d-c);//3
	}
	
	
	@Test
	public void testLinkedList01(){
		long a = System.currentTimeMillis();
		List list = new LinkedList<>();
		for (int i = 0; i < 100000; i++) {
			list.add(0, i);//new Node() addFirst  first.prev = node; node.next=first;
		}
		long b = System.currentTimeMillis();
		System.out.println(b - a);// 6
		
		System.out.println("-----------遍历测试-------------");
		for (int i = 0; i < list.size(); i++) {
			list.get(i);
		}
		long c = System.currentTimeMillis();
		System.out.println(c - b);// 3927
		
		System.out.println("-----------遍历foreach测试---------------");
		for (Integer i:list) {}
		long d = System.currentTimeMillis();
		System.out.println(d - c);// 3
	}
	
}

例如：模拟队列


/*
 * 我们用LinkedList来模拟队列
 * 1.向队列添加：offer
 * 2.从队列中取出：poll
 * 3.如果队列的元素被取空了，会返回null
 * 4.遍历取出队列中的元素
 */
public class Demo03_模拟队列 {
	public static void main(String[] args) {
		Queue list = new LinkedList<>();
		list.offer(3);
		list.offer(5);
		list.offer(6);
		list.offer(2);
		list.offer(3);
		// while (list.size() > 0) {
		// System.out.println(list.poll());
		// }
		while (!list.isEmpty()) {
			System.out.print(list.poll() + " ");//3 5 6 2 3 
		}
		// for 丢内容
		// for (int i = 0; i < list.size(); i++) {
		// System.out.println(list.poll());
		// }
		System.out.println(list);// []
	}
}

例如：用LinkedList模拟栈

import java.util.Deque;
import java.util.LinkedList;

/*
 * 用LinkedList模拟栈
 * 栈：stack 压栈
 * 压栈：push
 * 弹栈：pop
 * 如果集合中没有数据了，执行pop会报错：NoSuchElementException
 */
public class Demo04_LinkedList模拟栈_Stack {
	public static void main(String[] args) {
		Deque dq = new LinkedList<>();
		dq.push(4);
		dq.push(5);
		dq.push(1);
		System.out.println(dq.pop());//1
		System.out.println(dq.pop());//5
		System.out.println(dq.pop());//4
	}
}

7. 泛型

泛型:是]DK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查

泛型的格式:<数据类型>
注意:泛型只能支持引用数据类型

如果我们没有给集合指定类型，默认认为所有的数据类型都是object类型，此时集合中添加任意数据类型，导致我们在获取数据的时候，无法使用它的特有行为

在添加数据的时候就把类型进行统一，而且我们在获取数据的时候，也省的强转了。

泛型的好处：

  • 统一数据类型。
  • 把运行时期的问题提前到编译期间避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来

扩展知识点:

  • Java中的泛型是伪泛型
  • java文件中存在泛型，当java文件编译成字节码文件，泛型就会消失，这个过程叫泛型的擦除

注意：

  • 泛型中不能写基本数据类型
  • 指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
  • 如果不写泛型，类型默认是object

7.1 泛型可以定义的地方

类后面（泛型类）

方法上面（泛型方法）

接口后面（泛型接口）

7.1.1 泛型类

使用场景:当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类
格式:
 

修饰符 class 类名<类型>{
}

例如：

public class ArrayList{
}

此处E可以理解为变量,但是不是用来记录数据的，而是记录数据的类型，可以写成: T、E、K、V等。创建该类对象时，E就确定类型

例如：自己编写一个泛型类

import java.util.Arrays;

/*
 *编写一个类的时候，如果不确定类型，那么这个类就可以定义为泛型类。
 */
public class GenericsDemo02 {
    public static void main(String[] args) {
        MyArrayLiat list = new MyArrayLiat<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list);//[aaa, bbb, ccc, null, null, null, null, null, null, null]


        MyArrayLiat list2 = new MyArrayLiat<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        System.out.println(list2);//[1, 2, 3, null, null, null, null, null, null, null]


    }
}

class MyArrayLiat {
    Object[] obj = new Object[10];
    int size;

    public boolean add(E e) { //E不确定的类型 e形参的名字
        obj[size] = e;
        size++;
        return true;
    }

    public E get(int index) {
        return (E) obj[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(obj);
    }
} 
  
 
  
7.1.2 泛型方法
 
  
 
   
方法中形参类型不确定时：
 
   
     
    
  1. 可以使用类名后面定义的泛型，（所有方法都能用）
    2.  
    
  2. 在方法申明上定义自己的泛型，（只有本方法能用）
    3.  
   
 
   
格式：
 
   
修饰符 <类型> 返回值类型 方法名(类型 变量名){
}
 
   
例如：
 
   
public static  void test1(T t) {
}
 
   
此处T可以理解为变量，但是不是用来记录数据的，而是记录类型的，可以写成:T、E、K、V等。调用该方法时，T就确定类型
 
  
 
  
例如：定义一个泛型方法
 
  
import java.util.ArrayList;

public class GenericsDemo02 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        ListUtil.addAll(list, "aaa", "bbb", "ccc", "ddd");//[aaa, bbb, ccc, ddd]
        System.out.println(list);

        ArrayList list2 = new ArrayList<>();
        ListUtil.addAll(list2, 111, 222, 333, 444);//[111, 222, 333, 444]
        System.out.println(list2);
        ListUtil.addAll2(list2, 111, 222, 333, 444, 555, 666, 777);//[111, 222, 333, 444, 111, 222, 333, 444, 555, 666, 777]
        System.out.println(list2);
    }
}

/*
 *类中定义一个静态方法addAll，用来添加多个元素
 */
class ListUtil {
    private ListUtil() {
    }

    public static  void addAll(ArrayList list, E e1, E e2, E e3, E e4) {
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
    }

    public static  void addAll2(ArrayList list, E... e) {
        for (E e1 : e) {
            list.add(e1);
        }
    }
}

 
  
7.1.3 泛型接口
 
  
 
   
格式:
 
   
修饰符 interface 接口名<类型>{
}
 
   
例如：
 
   
public interface List {
}
 
   
重点: 如何使用一个带泛型的接口
 
   
泛型接口两种使用方式：
 方式1:实现类给出具体类型
 方式2:实现类延续泛型，创建对象时再确定
 
  
 
  
例如：泛型接口两种使用方式：
 
  
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class GenericsDemo03_泛型接口两种使用方式 {
    public static void main(String[] args) {
        //方式1:实现类给出具体类型
        MyArrayList2 list2 = new MyArrayList2();
        list2.add("aaa");

        //方式2:实现类延续泛型，创建对象时再确定
        MyArrayList3 list3 = new MyArrayList3<>();
        list3.add("aaa");
        MyArrayList3 list4 = new MyArrayList3<>();
        list4.add(111);
    }
}

//方式1:实现类给出具体类型
class MyArrayList2 implements List {

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public  T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection c) {
        return false;
    }

    @Override
    public boolean addAll(Collection c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator listIterator() {
        return null;
    }

    @Override
    public ListIterator listIterator(int index) {
        return null;
    }

    @Override
    public List subList(int fromIndex, int toIndex) {
        return null;
    }
}

//方式2:实现类延续泛型，创建对象时再确定
class MyArrayList3 implements List {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public  T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection c) {
        return false;
    }

    @Override
    public boolean addAll(Collection c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E element) {
        return null;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator listIterator() {
        return null;
    }

    @Override
    public ListIterator listIterator(int index) {
        return null;
    }

    @Override
    public List subList(int fromIndex, int toIndex) {
        return null;
    }
}
 
  
7.2 泛型的继承和通配符
 
  
 
   
泛型不具备继承性，但是数据具备继承性
 
  
 
  
例如：泛型不具备继承性，但是数据具备继承性
 
  
import java.util.ArrayList;

public class GenericsDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list1 = new ArrayList<>();
        ArrayList list2 = new ArrayList<>();
        ArrayList list3 = new ArrayList<>();
        //调用方法
        method(list1);
        //method(list2); //报错
        //method(list3); //报错
        //泛型里面写的什么类型，就只能传递什么类型

        //数据具备继承性
        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());
    }

    //泛型不具备继承性，

    public static void method(ArrayList list) {

    }
}

class Ye {
}

class Fu extends Ye {
}

class Zi extends Fu {
}
 
  
例如：定义一个方法，形参是一个集合，但集合中的数据类型不确定
 
  
import java.util.ArrayList;

/*
 *定义一个方法，形参是一个集合，但集合中的数据类型不确定
 */
public class GenericsDemo04{
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list1 = new ArrayList<>();
        ArrayList list2 = new ArrayList<>();
        ArrayList list3 = new ArrayList<>();
        method(list1);
        method(list2);
        method(list3);
    }

    public static  void method(ArrayList list) {

    }
}
class Ye {
}

class Fu extends Ye {
}

class Zi extends Fu {
}
 
  
例3：通配符
 
  
import java.util.ArrayList;

/*
 *定义一个方法，形参是一个集合，但集合中的数据类型不确定
 */
public class GenericsDemo04_泛型的通配符 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list1 = new ArrayList<>();
        ArrayList list2 = new ArrayList<>();
        ArrayList list3 = new ArrayList<>();
        ArrayList list4 = new ArrayList<>();
        method(list1);
        method(list2);
        method(list3);
        //method(list4);//报错

        method2(list1);
        method2(list2);
        // method2(list3);//报错
        //method(list4);//报错
    }

    /*
     *利用泛型方法有一个小弊端，此时他可以接受任意的数据类型
     *      Ye Fu zi Student
     * 希望:本方法虽然不确定类型，但是以后我希望只能传递Ye Fu zi
     *
     * 此时我们就可以使用泛型的通配符:
     *      ?也表示不确定的类型 通配
     *      它可以进行类型的限定
     *      ? extends E: 表示可以传递E或者E所有的子类类型，通配符的上限
     *      ? super E:表示可以传递E或者E所有的父类类型，通配符的下限
     *
     *应用场景:
     *  1.如果我们在定义类、方法、接口的时候，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。
     *  2.如果类型不确定，但是能知道以后只能传递某个继承体系中的，就可以泛型的通配符
     *
     * 泛型的通配符:
     *  关键点:可以限定类型的范围。
     */
    public static  void method(ArrayList list) {

    }

    public static  void method2(ArrayList list) {

    }
}
class Ye {
}

class Fu extends Ye {
}

class Zi extends Fu {
}

class Student {

}
 
  
例4：
 
  
import java.util.ArrayList;

/*
 *需求:
 * 定义一个继承结构:
 *                          动物
 *          猫                          狗
 *   波斯猫      狸花猫             泰迪        哈士奇
 *
 * 属性:名字，年龄
 * 行为:吃东西
 *  波斯猫方法体打印:一只叫做XXX的，X岁的波斯猫，正在吃小饼干
 *  狸花猫方法体打印: 只叫做XXX的，X岁的狸花猫，正在吃鱼
 *  泰迪方法体打印:一只叫做XXX的，X岁的泰迪，正在吃骨头，边吃边蹭
 *  哈士奇方法体打印:一只叫做XXX的，X岁的哈士奇，正在吃骨头，边吃边拆家
 *
 * 测试类中定义一个方法用于饲养动物
 *  public static void keepPet(Arraylist list)(
 *      //遍历集合，调用动物的eat 方法
 *  }
 *
 * 要求
 *  1: 该方法能养所有品种的猫。但是不能养狗要求
 *  2: 该方法能养所有品种的狗。但是不能养猫要求
 *  3: 该方法能养所有的动物，但是不能传递其他类型
 */
public class GenericsDemo05_泛型的通配符 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList<>();
        ArrayList list2 = new ArrayList<>();
        ArrayList list3 = new ArrayList<>();
        ArrayList list4 = new ArrayList<>();
        keepPet(list1);
        keepPet(list2);
        //keepPet(list3);   //报错
        //keepPet(list4);   //报错

        // keepPet2(list1); //报错
        //keepPet2(list2);//报错
        keepPet2(list3);
        keepPet2(list4);

        keepPet3(list1);
        keepPet3(list2);
        keepPet3(list3);
        keepPet3(list4);
    }

    //该方法能养所有品种的猫。但是不能养狗要求
    public static void keepPet(ArrayList list) {
        //遍历集合，调用动物的eat 方法
    }

    //该方法能养所有品种的狗。但是不能养猫要求
    public static void keepPet2(ArrayList list) {
        //遍历集合，调用动物的eat 方法
    }

    //该方法能养所有的动物，但是不能传递其他类型
    public static void keepPet3(ArrayList list) {
        //遍历集合，调用动物的eat 方法
    }
}

abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public abstract void eat();
}

//1.继承抽象类，重写里而所有的抽象方法
// 2.本身Cat也是一个抽象的，让Cat的子类再重写重写方法

abstract class Cat extends Animal {
//因为Cat的两个子类中eat方法体不一样
}

class PersianCat extends Cat {
    @Override
    public void eat() {
        System.out.println("一只叫做" + getName() + "的，" + getAge() + "岁的波斯猫，正在吃小饼干");
    }
}

class LiHuaCat extends Cat {
    @Override
    public void eat() {
        System.out.println("一只叫做" + getName() + "的，" + getAge() + "岁的狸花猫，正在吃鱼");
    }
}

abstract class Dog extends Animal {

}

class TeddyDog extends Dog {
    @Override
    public void eat() {
        System.out.println("一只叫做" + getName() + "的，" + getAge() + "岁的泰迪，正在吃骨头，边吃边蹭");
    }
}

class HuskDog extends Dog {
    @Override
    public void eat() {
        System.out.println("一只叫做" + getName() + "的，" + getAge() + "岁的哈士奇，正在吃骨头，边吃边拆家");
    }
}
 
  
8. Set系列集合
 
  
 
   
List系列集合：添加的元素是有序、可重复、有索引
 
   
这里的有序指存和取得的顺序一样，存1,2,3。取出来的也是1,2,3。和排序无任何关系。
 
   
可重复指集合中的元素可以重复。
 
   
有索引，我们可以通过索引获取集合中每一个元素。
 
   
 
   
Set系列集合：添加的元素是无序，不重复，无索引
 
   
无序指存和取得的顺序可能不一样，存1,2,3。取出来的不一定是1,2,3。
 
   
不重复指集合中存储的元素不能相同，可以利用这个特性进行元素的数据去重。
 
   
无索引指不能通过索引获取Set集合里面的每一个元素。
 
  
 
  
Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。
 
  
Collection是单列集合的顶层接口，所有方法被List和Set系列集合共享。
 
  
 
    
    
 
     方法名称 
     说明 
    
 
    
    
    
 
     public boolean add(E e) 
     把给定的对象添加到当前集合中 
    
 
    
 
     public void clear() 
     清空集合中所有的元素 
    
 
    
 
     public boolean remove(E e) 
     把给定的对象在当前集合中删除 
    
 
    
 
     public boolean contains(object obj) 
     判断当前集合中是否包含给定的对象 
    
 
    
 
     public boolean isEmpty() 
     判断当前集合是否为空 
    
 
    
 
     public int size() 
     返回集合中元素的个数/集合的长度 
    
 
    
  
 
  
例如：
 
  
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
public class SetDemo01_Set集合特点 {
    public static void main(String[] args) {
        //创建Set集合的对象
        Set list = new HashSet<>();
​
        //添加元素
        //System.out.println(list.add("aaa"));//true
        //System.out.println(list.add("aaa"));//false
        //不重复指集合中存储的元素不能相同，可以利用这个特性进行元素的数据去重。
        //第一次添加true，第二次添加失败
​
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ccc");
        System.out.println(list);//[aaa, ccc, bbb]
        //无序
​
        //迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");//aaa ccc bbb
        }
        System.out.println();//换行
​
        //增强for
        for (String s : list) {
            System.out.print(s + " ");//aaa ccc bbb
        }
        System.out.println();//换行
​
        //lambda表达式
        list.forEach(s -> {
            System.out.print(s + " ");//aaa ccc bbb
        });
    }
}
 
  
 
  
 
   
set集合的实现类 HashSet:无序、不重复、无索引 LinkedHashSet: 有序、不重复、无索引
 
   
TreeSet:可排序、不重复、无索引
 
  
 
  
 
   
set接口中的方法上基本上与Collection的API一致。
 
  
 
  
8.1 HashSet
 
  
 
   
HashSet 底层原理 HashSet集合底层采取哈希表存储数据哈希表是一种对于增删改查数据性能都较好的结构
 
   
哈希表组成 JDK8之前:数组+链表 JDK8开始:数组+链表+红黑树
 
  
 
  
 
   
哈希值：对象的整数表现形式
 
   
根据hashCode方法算出来的int类型的整数 该方法定义在object类中，所有对象都可以调用，默认使用地址值进行计算
 
   
一般情况下，会重写hashCode方法，利用对象内部的属性值计算哈希值
 
  
 
  
 
   
对象的哈希值特点： 1.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的 2.如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
 
   
3.在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。(哈希碰撞)
 
  
 
  
例如：
 
  
package yj.com.easthome2.day0813;
​
import java.util.Objects;
​
public class HashSetDemo01 {
    public static void main(String[] args) {
        HashStudent s1 = new HashStudent("nn", 5);
        HashStudent s2 = new HashStudent("nn", 5);
​
        //如果设有重写hashcode方法，不同对象计算出的哈看值是不同的
        System.out.println(s1.hashCode());//110086
        System.out.println(s2.hashCode());//110086
​
        //在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。(哈希碰撞)
        System.out.println("abc".hashCode());//96354
        System.out.println("acD".hashCode());//96354
​
    }
}
​
class HashStudent {
    private String name;
    private int age;
​
    public HashStudent() {
    }
​
    public HashStudent(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "HashStudent{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HashStudent that = (HashStudent) o;
        return age == that.age && Objects.equals(name, that.name);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
 
  
Java 集合详解_第65张图片
 
  
 
   
HashSet底层原理 1.JDK8以后，当链表长度超过8，而且数组长度大于等于64时，自动转换为红黑树 2.如果集合中存储的是自定义对象，必须要重写hashCode和equals方法
 
  
 
  
8.2 LinkedHashSet
 
  
 
   
LinkedHashSet底层原理 1.有序、不重复、无索引。 2.这里的有序指的是保证存储和取出的元素顺序一致 3.原理:底层数据结构是依然哈希表只是每个元素又额外的多了一个双链表的机制记录存储的顺序。
 
  
 
  
例如：
 
  
import java.util.LinkedHashSet;
​
public class LinkedHashDemo01 {
    public static void main(String[] args) {
        HashStudent s1 = new HashStudent("nn", 15);
        HashStudent s2 = new HashStudent("bb", 25);
        HashStudent s3 = new HashStudent("pd", 5);
        HashStudent s4 = new HashStudent("nn", 15);
​
        LinkedHashSet l = new LinkedHashSet<>();
​
        System.out.println(l.add(s1));//true
        System.out.println(l.add(s2));//true
        System.out.println(l.add(s3));//true
        System.out.println(l.add(s4));//false
        System.out.println(l);//[HashStudent{name='nn', age=15}, HashStudent{name='bb', age=25}, HashStudent{name='pd', age=5}]
    }
} 
  
 
   
1.LinkedHashSet集合的特点和原理是怎么样的?
 
   
     
    
  • 有序、不重复、无索引
    •  
    
  • 底层基于哈希表，使用双链表记录添加顺序
    •  
   
 
   
2.在以后如果要数据去重，我们使用哪个?
 
   
     
    
  • 默认使用HashSet
    •  
    
  • 如果要求去重且存取有序，才使用LinkedHashSet
    •  
   
 
  
 
  
8.3 TreeSet
 
  
 
   
TreeSet 的特点
 
   
     
    
  1. 不重复、无索引、可排序
    2.  
    
  2. 可排序: 按照元素的默认规则 (有小到大)排序。
    3.  
    
  3. TreeSet集合底层是基红黑树的数据结构实现排序的，增删改查性能都较好
    4.  
   
 
  
 
  
例如：
 
  
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo01 {
    public static void main(String[] args) {
        TreeSet set = new java.util.TreeSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);
        System.out.println(set);//[1, 2, 3, 4, 5]

        //遍历（3种都行）
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");//1 2 3 4 5
        }
        System.out.println();

        //增强for
        for (Integer integer : set) {
            System.out.print(integer + " ");//1 2 3 4 5
        }
        System.out.println();

        //Lambda
        set.forEach(integer -> {
                    System.out.print(integer + " ");//1 2 3 4 5
                }
        );
    }
}

 
  
 
   
TreeSet集合默认的规则：
 对于数值类型:Integer，Double，默认按照从小到大的顺序进行排序
 
   
对于字符、字符串类型:按照字符在ASCII码表中的数字升序进行排序
 
  
 
  
 
   
TreeSet的两种比较方式
 方式一:默认排序/自然排序:Javabean类实现Comparable接口指定比较规则
 方式二:比较器排序:创建TreeSet对象时候，传递比较器Comparator指定规则
 使用原则:默认使用第一种，如果第一种不能满足当前需求，就使用第二种
 
  
 
  
例如：方式一
 
  
import java.util.TreeSet;

public class TreeSetDemo02 {
    public static void main(String[] args) {
        TreeStudent s1 = new TreeStudent("zhangsan", 23);
        TreeStudent s2 = new TreeStudent("lisi", 25);
        TreeStudent s3 = new TreeStudent("wangwu", 24);

        TreeSet ts = new TreeSet<>();
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        System.out.println(ts);//[TreeStudent{name='zhangsan', age=23}, TreeStudent{name='wangwu', age=24}, TreeStudent{name='lisi', age=25}]


        //方式一


    }
}

class TreeStudent implements Comparable {
    private String name;
    private int age;

    public TreeStudent() {
    }

    public TreeStudent(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "TreeStudent{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(TreeStudent o) {
        //排序规则
        return this.getAge() - o.getAge();
    }
}
 
  
例如：方式二
 
  
import java.util.TreeSet;

/*
需求:请自行选择比较器排序和自然排序两种方式;
要求:存入四个字符小，c”，"ab"，"df"，“qwer"
按照长度排序，如果一样长则按照首字卧排序
 */
public class TreeSetDemo03 {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet<>((o1, o2) -> {
            //o1当前要添加的元素  o2已经在红黑树中存在的元素
            //按照长度排序
            int i = o1.length() - o2.length();
            //如果一样，默认排序
            i = i == 0 ? o1.compareTo(o2) : i;
            return i;
        }
        );
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");

        System.out.println(ts);//[c, ab, df, qwer]

    }
}

 
  
慢慢摸索的过程就是你学习的收获的过程。学习是一条令人时而喜极若狂、时而郁郁寡欢的道路，成长路上让我们携手共同进步。
 
  
文章为个人笔记，出自黑马阿伟，集合进阶-15-Tree第二种排序方式和综合练习_哔哩哔哩_bilibili
 
  
文章过长，上传的时候容易丢失内容，难免有不对的地方，还请指正。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,开发语言)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • html页面js获取参数值
                                    0624chenhong
html
                                    
    1.js获取参数值js 
function GetQueryString(name) 
 { 
      var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)"); 
      var r = windo
    
                                
    • 
                                
  • MongoDB 在多线程高并发下的问题
                                    BigCat2013
mongodbDB高并发重复数据
                                    
    最近项目用到 MongoDB , 主要是一些读取数据及改状态位的操作. 因为是结合了最近流行的 Storm进行大数据的分析处理，并将分析结果插入Vertica数据库，所以在多线程高并发的情境下, 会发现 Vertica 数据库中有部分重复的数据. 这到底是什么原因导致的呢？笔者开始也是一筹莫 展，重复去看 MongoDB 的 API , 终于有了新发现 ： 
com.mongodb.DB 这个类有
    
                                
    • 
                                
  • c++ 用类模版实现链表(c++语言程序设计第四版示例代码)
                                    CrazyMizzz
数据结构C++
                                    
    #include<iostream>
#include<cassert>
using namespace std;
template<class T>
class Node
{
private:
	Node<T> * next;
public:
	T data;                                    
    
                                
    • 
                                
  • 最近情况
                                    麦田的设计者
感慨考试生活
                                    
       在五月黄梅天的岁月里，一年两次的软考又要开始了。到目前为止，我已经考了多达三次的软考，最后的结果就是通过了初级考试（程序员）。人啊，就是不满足，考了初级就希望考中级，于是，这学期我就报考了中级，明天就要考试。感觉机会不大，期待奇迹发生吧。这个学期忙于练车，写项目，反正最后是一团糟。后天还要考试科目二。这个星期真的是很艰难的一周，希望能快点度过。 
  
    
                                
    • 
                                
  • linux系统中用pkill踢出在线登录用户
                                    被触发
linux
                                    
    由于linux服务器允许多用户登录，公司很多人知道密码，工作造成一定的障碍所以需要有时踢出指定的用户 
1/#who   查出当前有那些终端登录（用 w 命令更详细） 
# who 
root     pts/0        2010-10-28 09:36 (192
    
                                
    • 
                                
  • 仿QQ聊天第二版
                                    肆无忌惮_
qq
                                    
    在第一版之上的改进内容: 
 第一版链接: 
http://479001499.iteye.com/admin/blogs/2100893 
  
用map存起来号码对应的聊天窗口对象,解决私聊的时候所有消息发到一个窗口的问题. 
增加ViewInfo类,这个是信息预览的窗口,如果是自己的信息,则可以进行编辑. 
  
信息修改后上传至服务器再告诉所有用户,自己的窗口
    
                                
    • 
                                
  • java读取配置文件
                                    知了ing

                                    
    1，java读取.properties配置文件 
 
InputStream in;
		try {
			in = test.class.getClassLoader().getResourceAsStream("config/ipnetOracle.properties");//配置文件的路径
		    Properties p = new Properties()
    
                                
    • 
                                
  • __attribute__ 你知多少？
                                    矮蛋蛋
C++gcc
                                    
    原文地址: 
http://www.cnblogs.com/astwish/p/3460618.html 
GNU C 的一大特色就是__attribute__ 机制。__attribute__ 可以设置函数属性（Function Attribute ）、变量属性（Variable Attribute ）和类型属性（Type Attribute ）。 
 
__attribute__ 书写特征是：
    
                                
    • 
                                
  • jsoup使用笔记
                                    alleni123
java爬虫JSoup
                                    
    <dependency>
	<groupId>org.jsoup</groupId>
	<artifactId>jsoup</artifactId>
	<version>1.7.3</version>
</dependency>
 
 
 
 
 
2014/08/28 
今天遇到这种形式， 
    
                                
    • 
                                
  • JAVA中的集合 Collectio 和Map的简单使用及方法
                                    百合不是茶
listmapset
                                    
             List ,set ,map的使用方法和区别 
java容器类类库的用途是保存对象，并将其分为两个概念： 
    Collection集合：一个独立的序列，这些序列都服从一条或多条规则;List必须按顺序保存元素  ，set不能重复元素；Queue按照排队规则来确定对象产生的顺序（通常与他们被插入的
    
                                
    • 
                                
  • 杀LINUX的JOB进程
                                    bijian1013
linuxunix
                                    
    今天发现数据库一个JOB一直在执行，都执行了好几个小时还在执行，所以想办法给删除掉 
  
系统环境： 
   ORACLE 10G 
   Linux操作系统 
  
操作步骤如下： 
第一步.查询出来那个job在运行，找个对应的SID字段 
select * from dba_jobs_running--找到job对应的sid 
&n
    
                                
    • 
                                
  • Spring AOP详解
                                    bijian1013
javaspringAOP
                                    
            最近项目中遇到了以下几点需求，仔细思考之后，觉得采用AOP来解决。一方面是为了以更加灵活的方式来解决问题，另一方面是借此机会深入学习Spring AOP相关的内容。例如，以下需求不用AOP肯定也能解决，至于是否牵强附会，仁者见仁智者见智。 
1.对部分函数的调用进行日志记录，用于观察特定问题在运行过程中的函数调用
    
                                
    • 
                                
  • [Gson六]Gson类型适配器(TypeAdapter)
                                    bit1129
Adapter
                                    
    TypeAdapter的使用动机 
 Gson在序列化和反序列化时，默认情况下，是按照POJO类的字段属性名和JSON串键进行一一映射匹配，然后把JSON串的键对应的值转换成POJO相同字段对应的值，反之亦然，在这个过程中有一个JSON串Key对应的Value和对象之间如何转换(序列化/反序列化)的问题。 
  
以Date为例，在序列化和反序列化时，Gson默认使用java.
    
                                
    • 
                                
  • 【spark八十七】给定Driver Program， 如何判断哪些代码在Driver运行，哪些代码在Worker上执行
                                    bit1129
driver
                                    
    Driver Program是用户编写的提交给Spark集群执行的application，它包含两部分 
 
 作为驱动： Driver与Master、Worker协作完成application进程的启动、DAG划分、计算任务封装、计算任务分发到各个计算节点(Worker)、计算资源的分配等。 
 计算逻辑本身，当计算任务在Worker执行时，执行计算逻辑完成application的计算任务 
 
    
                                
    • 
                                
  • nginx 经验总结
                                    ronin47
nginx 总结
                                    
    　　　深感nginx的强大，只学了皮毛，把学下的记录。 
　　　获取Header 信息，一般是以$http_XX（ＸＸ是小写） 
           获取body,通过接口，再展开，根据Ｋ取Ｖ 
　　　获取uri,以$arg_XX 
     &n
    
                                
    • 
                                
  • 轩辕互动-1.求三个整数中第二大的数2.整型数组的平衡点
                                    bylijinnan
数组
                                    
    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class ExoWeb {

	public static void main(String[] args) {
		ExoWeb ew=new ExoWeb();
		
		System.out.pri
    
                                
    • 
                                
  • Netty源码学习-Java-NIO-Reactor
                                    bylijinnan
java多线程netty
                                    
    Netty里面采用了NIO-based Reactor Pattern 
了解这个模式对学习Netty非常有帮助 
 
参考以下两篇文章： 
 
http://jeewanthad.blogspot.com/2013/02/reactor-pattern-explained-part-1.html 
 
http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf 

    
                                
    • 
                                
  • AOP通俗理解
                                    cngolon
springAOP
                                    
    1.我所知道的aop     初看aop,上来就是一大堆术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下子让你不知所措，心想着：怪不得很多人都和 我说aop多难多难。当我看进去以后，我才发现：它就是一些java基础上的朴实无华的应用，包括ioc，包括许许多多这样的名词，都是万变不离其宗而 已。 2.为什么用aop&nb
    
                                
    • 
                                
  • cursor variable 实例
                                    ctrain
variable
                                    
    
create or replace procedure proc_test01
as 
type emp_row is record(
empno emp.empno%type,
ename emp.ename%type,
job emp.job%type,
mgr emp.mgr%type,
hiberdate emp.hiredate%type,
sal emp.sal%t
    
                                
    • 
                                
  • shell报bash: service: command not found解决方法
                                    daizj
linuxshellservicejps
                                    
    今天在执行一个脚本时，本来是想在脚本中启动hdfs和hive等程序，可以在执行到service hive-server start等启动服务的命令时会报错，最终解决方法记录一下： 
  
脚本报错如下： 
./olap_quick_intall.sh: line 57: service: command not found 
./olap_quick_intall.sh: line 59
    
                                
    • 
                                
  • 40个迹象表明你还是PHP菜鸟
                                    dcj3sjt126com
设计模式PHP正则表达式oop
                                    
    你是PHP菜鸟，如果你：1. 不会利用如phpDoc 这样的工具来恰当地注释你的代码2. 对优秀的集成开发环境如Zend Studio 或Eclipse PDT 视而不见3. 从未用过任何形式的版本控制系统，如Subclipse4. 不采用某种编码与命名标准 ，以及通用约定，不能在项目开发周期里贯彻落实5. 不使用统一开发方式6. 不转换（或）也不验证某些输入或SQL查询串（译注：参考PHP相关函
    
                                
    • 
                                
  • Android逐帧动画的实现
                                    dcj3sjt126com
android
                                    
    一、代码实现： 
private ImageView iv;
	private AnimationDrawable ad;
	
	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout
    
                                
    • 
                                
  • java远程调用linux的命令或者脚本
                                    eksliang
linuxganymed-ssh2
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2105862  
    
   Java通过SSH2协议执行远程Shell脚本(ganymed-ssh2-build210.jar)  
 使用步骤如下： 
1.导包 
官网下载: 
http://www.ganymed.ethz.ch/ssh2/ 
ma
    
                                
    • 
                                
  • adb端口被占用问题
                                    gqdy365
adb
                                    
    最近重新安装的电脑，配置了新环境，老是出现： 
 
 

 adb server is out of date.  killing...  
    ADB server didn't ACK  
    * failed to start daemon *  
 
百度了一下，说是端口被占用，我开个eclipse，然后打开cmd，就提示这个，很烦人。 
 
一个比较彻底的解决办法就是修改
    
                                
    • 
                                
  • ASP.NET使用FileUpload上传文件
                                    hvt
.netC#hovertreeasp.netwebform
                                    
    前台代码： 
<asp:FileUpload ID="fuKeleyi" runat="server" />
<asp:Button ID="BtnUp" runat="server" onclick="BtnUp_Click" Text="上 传" />
    
                                
    • 
                                
  • 代码之谜（四）- 浮点数（从惊讶到思考）
                                    justjavac
浮点数精度代码之谜IEEE
                                    
    在『代码之谜』系列的前几篇文章中，很多次出现了浮点数。 浮点数在很多编程语言中被称为简单数据类型，其实，浮点数比起那些复杂数据类型（比如字符串）来说， 一点都不简单。 
单单是说明 IEEE浮点数 就可以写一本书了，我将用几篇博文来简单的说说我所理解的浮点数，算是抛砖引玉吧。 一次面试 
记得多年前我招聘 Java 程序员时的一次关于浮点数、二分法、编码的面试， 多年以后，他已经称为了一名很出色的
    
                                
    • 
                                
  • 数据结构随记_1
                                    lx.asymmetric
数据结构笔记
                                    
    第一章 
  1.数据结构包括数据的
逻辑结构、数据的物理/存储结构和数据的逻辑关系这三个方面的内容。 2.数据的存储结构可用四种基本的存储方法表示，它们分别是
顺序存储、链式存储 、索引存储 和 散列存储。 3.数据运算最常用的有五种，分别是
 查找/检索、排序、插入、删除、修改。 4.算法主要有以下五个特性： 
输入、输出、可行性、确定性和有穷性。 5.算法分析的
    
                                
    • 
                                
  • linux的会话和进程组
                                    网络接口
linux
                                    
    会话： 一个或多个进程组。起于用户登录，终止于用户退出。此期间所有进程都属于这个会话期。会话首进程：调用setsid创建会话的进程1.规定组长进程不能调用setsid，因为调用setsid后，调用进程会成为新的进程组的组长进程.如何保证？ 先调用fork，然后终止父进程，此时由于子进程的进程组ID为父进程的进程组ID，而子进程的ID是重新分配的，所以保证子进程不会是进程组长，从而子进程可以调用se
    
                                
    • 
                                
  • 二维数组 元素的连续求解
                                    1140566087
二维数组ACM
                                    
    import java.util.HashMap;




public class Title {
	public static void main(String[] args){
		f();
	}

	// 二位数组的应用
	//12、二维数组中，哪一行或哪一列的连续存放的0的个数最多，是几个0。注意，是“连续”。
	public static void f(){

    
                                
    • 
                                
  • 也谈什么时候Java比C++快
                                    windshome
javaC++
                                    
      
刚打开iteye就看到这个标题“Java什么时候比C++快”，觉得很好笑。 
  
你要比，就比同等水平的基础上的相比，笨蛋写得C代码和C++代码，去和高手写的Java代码比效率，有什么意义呢？ 
  
我是写密码算法的，深刻知道算法C和C++实现和Java实现之间的效率差，甚至也比对过C代码和汇编代码的效率差，计算机是个死的东西，再怎么优化，Java也就是和C
    
                                
    •