鹤鸣呦呦、、

Java--集合框架详解

文章目录

- 1、集合概念
- 2、Collection接口
- - 2.1、Collection父接口
  - 2.2、**Collection的使用**
- 3、List接口与实现类
- - 3.1、List子接口
  - 3.2、List子接口的使用
  - 3.3、List实现类
  - - 3.3.1、ArrayList
    - 3.3.2、Vector
    - 3.3.3、LinkedList
  - 3.4、ArrayList与LinkedList的区别
- 4、泛型和工具类
- 5、Set接口与实现类
- - 5.1、Set子接口
  - 5.2、Set子接口的使用
  - 5.3、Set实现类
  - - 5.3.1、HashSet
    - 5.3.2、TreeSet
- 6、Map接口与实现类
- - 6.1、Map父接口与简单使用
  - 6.2、Map集合的实现类
  - - 6.2.1、HashMap
    - 6.2.2、HashMap源码分析
- 7、Collections工具类
- 8、集合总结

##前言
Java集合框架的知识在Java基础阶段是极其重要的，我平时使用List、Set和Map集合时经常出错，常用方法还记不牢，
于是就编写这篇博客来完整的学习一下Java集合框架的知识，如有遗漏和错误，欢迎大家指出。
以下是我整理的大致Java集合框架内容，本篇博客就是围绕以下内容展开

注：本篇博客是根据B站Java集合框架的视频进行编写，视频原地址：【千锋】最新版 Java集合框架详解通俗易懂

下面我们开始正式学习！！！

1、集合概念

1.1、概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

1.2、集合与数组区别：

数组长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型

1.3、位置：java.util*

2、Collection接口

Collection体系集合

2.1、Collection父接口

特点:代表一组任意类型的对象，无序、无下标、不能重复
方法：

2.2、Collection的使用

（1）Demo1保存字符串（重点关注迭代器iterator的使用）

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

public class Demo1 {
    public static void main(String[] args) {
        //创建集合
        Collection collection = new ArrayList();
        //1.添加元素
        collection.add("香蕉");
        collection.add("苹果");
        collection.add("西瓜");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);

        //2.删除元素
        //collection.remove("香蕉");
        //collection.clear();//清除
        //System.out.println("删除之后："+collection.size());

        //3.遍历元素(重点)
        System.out.println("==========================");
        //方法一：增强for
        for (Object object:collection) {
            System.out.println(object);
        }
        //方法二：使用迭代器（迭代器专门用来遍历集合的一种方式）
        //iterator3个方法
        //hasNext();有没有下一个元素
        //next();l获取下一个元素
        //remove();删除当前元素
        System.out.println("==========================");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
            System.out.println(s);
            // collection.remove(s);//不允许使用collection删除会引发并发修改错误，只能使用以下方法移除
            //iterator.remove();
        }
        System.out.println("元素个数："+collection.size());


        //4.判断
        System.out.println(collection.contains("香蕉"));
        System.out.println(collection.isEmpty());


    }
}

结果

（2）Demo2 保存学生信息

学生类

//学生类
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

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

    public int getAge() {
        return age;
    }

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

    public Student() {
    }

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

}

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

//  保存学生信息
public class Demo2 {
    public static void main(String[] args) {
        //新建Collection对象
        Collection collection = new ArrayList();

        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",19);
        Student s3 = new Student("王五",21);
        //1.添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        
        System.out.println("元素个数："+collection.size());
        System.out.println(collection.toString());

        //2.删除
        //collection.remove(s1);
        //System.out.println("删除之后："+collection.size());

        //3.遍历
        //方法一：增强for
        System.out.println("========增强for===========");
        for (Object object:collection) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }

        //方法二：使用迭代器（迭代器专门用来遍历集合的一种方式）
        System.out.println("========使用迭代器===========");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Student s =(Student) iterator.next();
        }
        System.out.println(collection.toString());

        //4.判断
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());


    }
}

结果

3、List接口与实现类

3.1、List子接口

特点：有序，有下标，元素可以重复
方法：

3.2、List子接口的使用

（1）Demo3

public class Demo3 {
    public static void main(String[] args) {
        //先创建一个集合对象
        List list = new ArrayList();
        //1.添加元素
        list.add("唱");
        list.add("跳");
        list.add(0,"打篮球");//下标为0，放在第一位
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());

        //2.删除元素
//        list.remove("唱");
//        list.remove(1);
//        System.out.println("元素个数:"+list.size());
//        System.out.println(list.toString());


        //3.遍历
        //方法一:使用for遍历
        System.out.println("===========for遍历===============");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        //方法二:使用增强for
        System.out.println("===========增强for===============");
        for (Object o:list) {
            System.out.println(o);
        }

        //方法三:使用迭代器
        System.out.println("===========迭代器===============");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //方法四:使用列表迭代器
        //和迭代器的区别：可以向前或向后遍历，添加、删除、修改元素
        System.out.println("===========列表迭代器===============");
        ListIterator lit = list.listIterator();

        System.out.println("===========列表迭代器从前往后===============");
        while (lit.hasNext()) {
            System.out.println(lit.nextIndex()+":"+lit.next());
        }

        System.out.println("===========列表迭代器从后往前===============");
        while (lit.hasPrevious()) {
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }


        System.out.println("==========================");
        //4.判断
        System.out.println(list.contains("rap"));
        System.out.println(list.isEmpty());

        //5.获取位置
        System.out.println(list.indexOf(2));

    }

}

结果

（2）Demo4

public class Demo4 {
    public static void main(String[] args) {
        //先创建一个集合对象
        List list = new ArrayList();
        //1.添加数字数据(自动装箱)
        list.add(17);
        list.add(27);
        list.add(37);
        list.add(47);
        list.add(57);
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());

        //2.删除
        //注意这里是用脚标删除的，如果要用数字需要转成Object
        list.remove(0);
        //list.remove((Object) 17);
        //list.remove(new Integer(20));

        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());


        //3.补充方法subList:返回子集合，包含头不包含尾
        List subList = list.subList(1, 3);
        System.out.println(subList.toString());


    }
}

结果：

3.3、List实现类

ArrayList（重点）：
- 数组结构实现，查询快，增删慢
- jdk1.2版本后加入,运行效率快，线程不安全
Vector:
- 数组结构实现，查询快，增删慢
- jdk1.0版本后加入,运行效率慢，线程安全
LinkedList:
- 链表结构实现，增删快，查询慢

3.3.1、ArrayList

/**
 * ArrayList的使用
 * 特点：有序，有下标，可以重复
 * 存储结构：数组，查找遍历速度快，增删慢
 */

public class Demo5 {
    public static void main(String[] args) {
        //创建结合
        ArrayList arrayList = new ArrayList();

        //1.添加元素
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",23);
        Student s3 = new Student("王五",19);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());

        //2.删除元素
//        arrayList.remove(0);
//        arrayList.remove(s2);
        arrayList.remove(new Student("ooof",12));//这样删除需要在Student中重写 equals(this == obj) 方法

        //3.遍历元素【重点】
        //使用迭代器
        System.out.println("========= 使用迭代器=========");
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            Student s =(Student) it.next();
            System.out.println(s.toString());
        }
        //列表迭代器
        System.out.println("========= 列表迭代器=========");
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()) {
            Student s =(Student) lit.next();
            System.out.println(s.toString());
        }


        System.out.println("========= 列表迭代器逆序=========");

        while (lit.hasPrevious()) {
            Student s =(Student) lit.previous();
            System.out.println(s.toString());
        }

        //4.判断
        System.out.println(arrayList.contains(new Student("王五",19)));
        System.out.println(arrayList.isEmpty());
        //5.查找
        System.out.println(arrayList.indexOf(new Student("王五",19)));
    }
}

结果

源码分析

默认容量:DEFAULT_CAPACITY = 10;
- 注：如果没有向集合中添加任何元素，容量为0,添加一个元素之后，容量为10，每次扩容大小为原来的1.5 倍
存放元素的数组：elementData
实际元素个数：size

添加元素：add()方法

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}




   public void ensureCapacity(int minCapacity) {
        if (minCapacity > elementData.length
            && !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
                 && minCapacity <= DEFAULT_CAPACITY)) {
            modCount++;
            grow(minCapacity);
        }
    }

//grow为核心
    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

3.3.2、Vector

存储结构：数组
创建集合 Vector vector = new Vector<>();
增加（vector.add()）、删除(vector.remove)、判断(vector.contains())同上
遍历–枚举器遍历

Enumeration en = vector.elements();
while(en.hasMoreElements()){
  String s = (String)en.nextElement();
  sout(s);
}

3.3.3、LinkedList

/**
 *LinkedList的使用
 * 存储结构：双向链表
 * 可以重复添加
 */
public class LinkedListTest1 {
    public static void main(String[] args) {

        //创建集合
        LinkedList linkedList = new LinkedList<>();
        //1.添加元素
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",23);
        Student s3 = new Student("王五",19);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);

        System.out.println("元素个数:"+linkedList.size());
        System.out.println(linkedList.toString());

        //2.删除
//        linkedList.remove(s1);
//        System.out.println("删除之后:"+linkedList.size());

        //3.遍历
        //for遍历
        System.out.println("========for=====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        System.out.println("========增强for=====");
        for (Object object:linkedList) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        //迭代器
        System.out.println("========迭代器=====");
        Iterator it = linkedList.iterator();
        while (it.hasNext()) {
            Student s =(Student) it.next();
            System.out.println(s.toString());
        }
        System.out.println("========列表迭代器=====");
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()) {
            Student s =(Student) lit.next();
            System.out.println(s.toString());
        }

        //4.判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());

        //5.获取
        System.out.println(linkedList.indexOf(s1));

    }
}

结果

源码分析

transient int size = 0;//集合大小

 transient Node first;//头结点
 
 transient Node last;//尾节点
 
  public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
   void linkLast(E e) {
        final Node l = last;
        final Node newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

3.4、ArrayList与LinkedList的区别

ArrayList：数组，必须开辟连续空间，查询快，增删慢
LinkedList：双向链表，无需开辟连续空间，查询慢，增删快

4、泛型和工具类

泛型

Java泛型是JDK1.5中引入的一个新特性，其本质是參数化类型，把类型作为参数传递
常见形式有泛型类、泛型接口、泛型方法
语法：
好处：
- (1）提高代码的重用性
- (2）防止类型转换异常，提高代码的安全性

泛型类

/**
 * 泛型类
 * 语法：
 * T表示类型占位符，表示一种引用类型，如果编写多个用逗号隔开
 * */
public class MyGeneric<T> {
    //使用泛型T
    //1.创建变量,不能new T()因为T数据类型不确定
    T t;

    //2.创建一个方法，作为方法的参数
    public void show(T t){
        System.out.println(t);
    }

    //3.使用泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意：1.泛型只能使用引用类型，2.不同泛型类型对象之间不能相互赋值

        MyGeneric<String> myGeneric = new MyGeneric<String>();
        myGeneric.t = "hello";
        myGeneric.show("你好");
        String t1 = myGeneric.getT();


        MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
        myGeneric2.t = 100;
        myGeneric2.show(200);
        Integer t2 = myGeneric2.getT();


    }
}

结果：

泛型接口

/**
 *泛型接口
 * 语法：接口名
 * 注意：不能使用泛型来创建静态常量
 */

public interface MyInterface<T> {
    String name = "张三";

    T server(T t);
}

泛型接口实现有两种方法：

1、指定数据类型

public class MyInterfaceImpl implements MyInterface<String>{
    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

测试

MyInterfaceImpl impl = new MyInterfaceImpl();
impl.server("KKKKKKKK");

2、不指定数据类型

public class MyInterfaceImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }

测试

MyInterfaceImpl2 impl2 = new MyInterfaceImpl2();
impl2.server(1000);

结果：

泛型方法

/**
 *泛型方法
 * 语法:返回值类型
 */


public class MyGenericMethod {
    //泛型方法
    public <T> void show(T t){
        System.out.println("泛型方法"+t);
    }
}

测试

//泛型方法
//不需要指定类型
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("坤坤");
myGenericMethod.show(200);
myGenericMethod.show(3.1415);

结果：

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
- 编译时即可检查，而非逐行时抛出异常。
- 访问时，不必类型转换（拆箱）。
- 不同泛型之间引用不能相互赋值，泛型不存在多态。

public class DemoCollect {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("xxx");
        arrayList.add("yyy");
        //指定String类型一下两条数据就不能添加进去
//        arrayList.add(10);
//        arrayList.add(20);

        for (String str:arrayList) {
            System.out.println(str);
        }


        ArrayList<Student> arrayList2 = new ArrayList<Student>();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",19);
        Student s3 = new Student("王五",21);
        arrayList2.add(s1);
        arrayList2.add(s2);
        arrayList2.add(s3);

        Iterator<Student> iterator = arrayList2.iterator();
        while (iterator.hasNext()) {
            Student s = iterator.next();
            System.out.println(s.toString());
        }


    }
}

测试

5、Set接口与实现类

5.1、Set子接口

特点：无序，无下标，元素不可重复
方法：全部继承自Collecton中的方法

5.2、Set子接口的使用

/**
 * 测试Set接口的使用
 * 特点：无序，无下标，元素不可重复
 */


public class Demo1 {
    public static void main(String[] args) {
        //创建集合
        HashSet<String> set = new HashSet<>();
        //1.添加数据
        set.add("唱");
        set.add("跳");
        set.add("rap");
        //set.add("rap");重复添加不进去
        System.out.println("数据个数:"+set.size());
        System.out.println(set.toString());

        //2.删除
        set.remove("唱");
        System.out.println(set.toString());

        //3.遍历【重点】
        System.out.println("----增强for----");
        for (String str:set) {
            System.out.println(str);
        }
        System.out.println("----迭代器----");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }

        //4.判断
        System.out.println(set.contains("打篮球"));
        System.out.println(set.isEmpty());

        

    }
}

测试：（注意这里添加的顺序与显示的顺序不同，因为无序）

5.3、Set实现类

HashSet【重点】：
- 基于HashCode实现元素不重复。
- 当存入元素的哈希码相同时，会调用equalsi进行确认，如结果为true,则拒绝后者存入。
TreeSet:
- 基于排列顺序实现元素不重复。
- 实现了SortedSet接口，对集合元素自动排序
- 元素对象的类型必须实现Comparable接口，指定排序规则
- 通过CompareTo方法确定是否为重复元素

5.3.1、HashSet

HashSet的使用

（1）Demo2

/***
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 */
public class Demo2 {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet = new HashSet<>();
        //1.添加元素
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("王五");
        hashSet.add("赵六");
        System.out.println("数据个数:"+hashSet.size());
        System.out.println(hashSet.toString());

        //2.删除
        hashSet.remove("张三");
        System.out.println("删除后数据个数:"+hashSet.size());
        System.out.println(hashSet.toString());

        //3.遍历
        System.out.println("----增强for----");
        for (String str:hashSet) {
            System.out.println(str);
        }
        System.out.println("----迭代器----");
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }

        //4.判断
        System.out.println(hashSet.contains("打篮球"));
        System.out.println(hashSet.isEmpty());



    }

}

测试

（2）Demo3

person类

public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }

    public Person() {
    }

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



    @Override
    public int hashCode() {
        int n1 = this.name.hashCode();
        int n2 = this.age;
        return n1+n2;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        if(o instanceof Person){
        Person person = (Person) o;
        if(this.name.equals(person.getName())&&this.age == person.getAge()){
            return true;
        }
        }
        return false;
    }

    
}

Demo3

/***
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 存储过程：
 * （1）根据hashcode计算保存位置，如果位置为空，则直接保存，如果不为空，执行第二步
 * （2）再执行equals方法，如果equals方法为true，则认为是重复，否则形成链表
 */
public class Demo3 {
    public static void main(String[] args) {


    //新建集合
    HashSet<Person> persons = new HashSet<>();
    //1.添加元素
    Person p1 = new Person("乔纳森-乔斯达",20);
    Person p2 = new Person("乔瑟夫-乔斯达",19);
    Person p3 = new Person("空条承太郎",16);

    persons.add(p1);
    persons.add(p2);
    persons.add(p3);
    persons.add(new Person("空条承太郎",16));//重写hashCode()形成链表,再重写equals()就不能添加进来了

    System.out.println("元素个数:"+persons.size());
    System.out.println(persons.toString());

    //2.删除

//    persons.remove(p1);
//    persons.remove( new Person("乔纳森-乔斯达",20));//这时可以删除
//    System.out.println("删除之后："+persons.toString());

    //3.遍历
        System.out.println("------for----");
        for (Person person:persons) {
            System.out.println(person.toString());
        }
        System.out.println("------迭代器----");
        Iterator<Person> iterator = persons.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    //4.判断
        System.out.println(persons.contains(p1));
        System.out.println(persons.isEmpty());

    }
}

测试

5.3.2、TreeSet

（1）简单使用

/**
 * TreeSet的使用
 * 存储结构：红黑树
 */
public class Demo4 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        //1.添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("wer");
        treeSet.add("opq");
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());

        //2.删除
        treeSet.remove("wer");
        System.out.println("删除后元素个数："+treeSet.size());

        //3.遍历
        for (String str:treeSet) {
            System.out.println(str);
        }

        //4.判断
        System.out.println(treeSet.contains("opq"));

    }
}

（2）保存Person类的数据

/**
 * 使用TreeSet保存数据
 * 存储结构：红黑树
 * 要求：元素必须要实现Comparable接口,compareTo方法返回值为0，认为是重复元素
 */

public class Demo5 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Person> persons = new TreeSet<>();
        //1.添加元素
        Person p1 = new Person("7乔纳森-乔斯达",20);
        Person p2 = new Person("5乔瑟夫-乔斯达",19);
        Person p3 = new Person("3东方仗助",16);
        Person p4 = new Person("3东方仗助",17);

        //直接添加不能添加进去，因为没有比较规则，即没有实现Comparable接口，需要在Person类中实现
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);

        System.out.println("元素个数："+persons.size());
        System.out.println(persons.toString());

        //2.删除
        persons.remove(p4);
        System.out.println("元素个数："+persons.size());

        //3.遍历
        Iterator<Person> iterator = persons.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //4.判断
        System.out.println(persons.contains(p1));
    }
}

person类没有实现Comparable接口

person类实现Comparable接口

public class Person implements Comparable<Person>{
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }

    public Person() {
    }

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



    @Override
    public int hashCode() {
        int n1 = this.name.hashCode();
        int n2 = this.age;
        return n1+n2;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        if(o instanceof Person){
        Person person = (Person) o;
        if(this.name.equals(person.getName())&&this.age == person.getAge()){
            return true;
        }
        }
        return false;
    }

    //先按姓名比再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age - o.getAge();
        return n1==0?n2:n1;
    }
}

测试

Comparator接口实现定制比较（不需要元素实现Comparable接口）

/**
 * 使用TreeSet保存数据
 * 存储结构：红黑树
 * Comparator:实现定制比较（比较器）
 */
public class Demo6 {
    public static void main(String[] args) {
        //创建集合，并指定比较规则（匿名内部类）
        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
            @Override
            //先比较年龄再比较姓名
            public int compare(Person o1, Person o2) {
                int n1 = o1.getAge() - o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });

        //1.添加元素
        Person p1 = new Person("7乔纳森-乔斯达",20);
        Person p2 = new Person("5乔瑟夫-乔斯达",19);
        Person p3 = new Person("3东方仗助",16);
        Person p4 = new Person("4东方仗助",16);


        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);

        System.out.println(persons.toString());

    }

}

测试

TreeSet案例

/**
 * 要求：使用TreeSet集合实现字符串按照长度进行排序
 * Comparator实现定制比较
 *
 */
public class Demo7 {
    public static void main(String[] args) {
        //创建集合并指定比较规则
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {

                int n1 = o1.length() - o2.length();
                int n2 = o1.compareTo(o2);

                return n1==0?n2:n1;
            }
        });
        //添加数据
        treeSet.add("hello");
        treeSet.add("hello,world");
        treeSet.add("dalian");
        treeSet.add("kunkun");
        treeSet.add("ikun");
        treeSet.add("cat");
        treeSet.add("beijing");

        System.out.println(treeSet.toString());

    }
}

测试

6、Map接口与实现类

Map体系集合

Map接口的特点：

用于存储任意键值对(Key-Value)
键：无序、无下标、不允许重复（唯一）
值：无序、无下标、允许重复

6.1、Map父接口与简单使用

Map父接口

特点：存储一对数据(Key-Value),无序、无下标，键不可重复，值可重复。
方法：
- V put(K key,V value) //将对象存入到集合中，关联键值。key重复则覆盖原值。
- Object get(Object key)//根据键获取对应的值。
- Set keySet() //返回所有key。
- Collectionvalues()//返回包含所有值的Collection集合。
- Set>//键值匹配的Set集合。

Map接口使用

/**
 * Map接口的使用
 * 特点：（1）存储键值对（2）键不能重复，值可以重复（3）无序
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建Map集合

        Map<String, String> map = new HashMap<>();
        //1.添加元素
        map.put("tom","汤姆");
        map.put("jack","杰克");
        map.put("rose","露丝");

        //map.put("rose","ooo");value会被替换

        System.out.println("元素个数："+map.size());
        System.out.println(map.toString());

        //2.删除
//        map.remove("tom");
//        System.out.println("删除后元素个数："+map.size());

        //3.遍历
        //3.1使用keySet()
        System.out.println("-------keySet()遍历---------");
        //Set keySet = map.keySet();
        for(String key:map.keySet()){
            System.out.println(key+"---"+map.get(key));
        }
        //3.2使用entrySet()
        System.out.println("-------entrySet()遍历---------");
        //Set> entries = map.entrySet();
        for (Map.Entry<String, String> entry: map.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());

        }

        //4.判断
        System.out.println(map.containsKey("jack"));
        System.out.println(map.containsValue("杰克"));


    }
}

测试

keySet()与entrySet()

6.2、Map集合的实现类

HashMap【重点】
- jdk1.2版本，线程不安全，运行效率快
- 允许使用null作为key或value
Hashtable【了解】
- jdk1.0版本，线程安全，运行效率慢
- 不允许使用null作为key或value
Properties
- Hashtable的子类
- 要求key和value都是String
- 通常用于配置文件的读取
TreeMap
- 实现了SortedMap接口（是Map的子接口），可以对key自动排序

6.2.1、HashMap

Student类：

public class Student {
    private String name;
    private int stuNo;

    public Student(String name, int stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public int getStuNo() {
        return stuNo;
    }

    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }

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

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

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

/**
 * HashMap集合的使用
 * 存储结构：哈希表(数组+链表+红黑树)
 * 存储过程：
 *  （1）根据hashcode计算保存位置，如果位置为空，则直接保存，如果不为空，执行第二步
 *  （2）再执行equals方法，如果equals方法为true，则认为是重复，否则形成链表
 */

public class Demo2 {
    public static void main(String[] args) {
        //创建集合
        HashMap<Student,String> students = new HashMap<>();
        //1.添加元素
        Student s1 = new Student("张三",503);
        Student s2 = new Student("李四",509);
        Student s3 = new Student("王五",505);
        students.put(s1,"3班");
        students.put(s2,"7班");
        students.put(s3,"8班");
        //students.put(s3,"9班");键重复不能添加进去，但是值会覆盖
        students.put(new Student("张三",503),"3班");
        //会添加进去，new会在堆中新创建一个对象，如果要让它添加不进去，要在Student中重写hashcode和equals方法

        System.out.println("元素个数："+students.size());
        System.out.println(students.toString());
        
        //2.删除
//        students.remove(s1);
//        System.out.println("删除之后："+students.size());

        //3.遍历
        
        //keySet()
        System.out.println("-------keySet()遍历---------");
        for (Student key: students.keySet()) {
            System.out.println(key.toString()+"========="+students.get(key));
        }
        System.out.println("-------entrySet()遍历---------");
        for (Map.Entry<Student,String> entry: students.entrySet()) {
            System.out.println(entry.getKey()+"========="+entry.getValue());
        }
        
        //4.判断
        System.out.println(students.containsKey(s1));
        
        


    }
}

测试

6.2.2、HashMap源码分析

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;       // aka 16  HashMap初始容量大小

static final int MAXIMUM_CAPACITY = 1 << 30;              // HashMap数组的最大容量
 
static final float DEFAULT_LOAD_FACTOR = 0.75f;           //默认加载因子为0.75（到75%时扩容）

static final int TREEIFY_THRESHOLD = 8;                  //链表长度大于8时，调整成红黑树
 
static final int UNTREEIFY_THRESHOLD = 6;                //链表长度小于6时，调整成链表

static final int MIN_TREEIFY_CAPACITY = 64;             //链表长度大于8,并且集合元素个数大于等于64时，调整成红黑树

transient Node<K,V>[] table;                            //哈希表中的数组

transient int size;                                     //元素个数

构造函数

 public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    
 //刚创建HashMap之后没有添加元素 table=null，size=0  目的是节省空间

put方法（这个源码不太容易理解，大家尝试理解前每个方法的前几行就可以，有能力的可以深入研究）

//put方法  
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

//putVal方法
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

// resize()方法
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

HashMap源码简单总结

HashMap刚创建时，table是null,为了节省空间，当添加第一个元素时，table容量调整为16
当元素个数大于阈值(16*0.75=12)时，会进行扩容，扩容后大小为原来的2倍，目的是减少调整元素的个数
jdk1.8,当每个链表长度大于8，并且数组元素个数大于等于64时，会调整为红黑树，日的提高执行效率
jdk1.8当链表长度小于6时，调整成链表
jdk1.8以前，链表是头插入，jdk1.8以后是尾插入

7、Collections工具类

概念：集合工具类，定义了除存取以外的集合常用方法
方法：

代码实现

/**
 * Collections工具类的使用
 *
 */
public class Demo4 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(77);
        list.add(23);
        list.add(89);
        list.add(12);

        //sort排序
        System.out.println("排序前："+list.toString());
        Collections.sort(list);//升默认序
        System.out.println("排序后："+list.toString());


        //binarySearch二分查找， 找到为下标，没找到为负数
        int i = Collections.binarySearch(list, 12);
        System.out.println(i);

        //copy复制
        List<Integer> dest = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {
            dest.add(0);
        }
        Collections.copy(dest,list);
        System.out.println(dest.toString());


        //reverse反转
        Collections.reverse(list);
        System.out.println("反转之后："+list);

        //shuffle  打乱
        Collections.shuffle(list);
        System.out.println("打乱之后："+list);


        //补充：list 转成数组
        System.out.println("=======list 转成数组========");
        Integer[] integers = list.toArray(new Integer[0]);
        System.out.println(integers.length);
        System.out.println(Arrays.toString(integers));


        //数组转成集合
        System.out.println("=======数组转成集合========");
        String[] names = {"小明","小红","小王"};
        //集合是一个受限集合，不能添加和删除
        List<String> list1 = Arrays.asList(names);
        System.out.println(list1);

        //把基本类型数组转成集合时，需要修改为包装类
        Integer[] nums = {100,200,300,400,500};
        List<Integer> integerList = Arrays.asList(nums);
        System.out.println(integerList);


    }
}

测试

8、集合总结

最后，我们再看一下这张图回顾一下Java集合框架的重点和常用知识

集合的概念：
- 对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
List集合：
- 有序、有下标、元素可以重复。(ArrayList、LinkedList、Vector)
Set集合：
- 无序、无下标、元素不可重复。(HashSet、TreeSet)
Map集合：
- 存储一对数据，无序、无下标，键不可重复，值可重复。(HashMap、HashTable、TreeMap)
Collections:
- 集合工具类，定义了除了存取以外的集合常用方法。

到这里关于Java集合框架的知识就结束啦°꒰๑’ꀾ’๑꒱°，希望大家都有所收获，觉得文章还可以的话可以点个推荐支持博主啊

你可能感兴趣的:(Java基础,java,jvm,开发语言,面试)

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 开发语言 sdl2 linux
需求：操作系统为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前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
MYSQL面试系列-04 king01299 面试 mysql 面试
MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
Kafka 消息丢失如何处理？架构文摘JGWZ 学习
今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）算法大师华为od 面试 python 算法前端
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面一个射手座的程序媛程序员华为od 面试职场和发展
最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
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 Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、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 python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
2019考研 | 西交大软件工程笔者阿蓉
本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、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）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
ASM系列五利用TreeApi 解析生成Class lijingyao8206 ASM 字节码动态生成 ClassNode TreeAPI
前面CoreApi的介绍部分基本涵盖了ASMCore包下面的主要API及功能，其中还有一部分关于MetaData的解析和生成就不再赘述。这篇开始介绍ASM另一部分主要的Api。TreeApi。这一部分源码是关联的asm-tree-5.0.4的版本。在介绍前，先要知道一点， Tree工程的接口基本可以完
链表树——复合数据结构应用实例 bardo 数据结构树型结构表结构设计链表菜单排序
我们清楚：数据库设计中，表结构设计的好坏，直接影响程序的复杂度。所以，本文就无限级分类（目录）树与链表的复合在表设计中的应用进行探讨。当然，什么是树，什么是链表，这里不作介绍。有兴趣可以去看相关的教材。需求简介：经常遇到这样的需求，我们希望能将保存在数据库中的树结构能够按确定的顺序读出来。比如，多级菜单、组织结构、商品分类。更具体的，我们希望某个二级菜单在这一级别中就是第一个。虽然它是最后
为啥要用位运算代替取模呢 chenchao051 位运算哈希汇编
在hash中查找key的时候，经常会发现用&取代%，先看两段代码吧， JDK6中的HashMap中的indexFor方法： /** * Returns index for hash code h. */ static int indexFor(int h, int length) {
最近的情况麦田的设计者生活感悟计划软考想
今天是2015年4月27号整理一下最近的思绪以及要完成的任务 1、最近在驾校科目二练车，每周四天，练三周。其实做什么都要用心，追求合理的途径解决。为
PHP去掉字符串中最后一个字符的方法 IT独行者 PHP 字符串
今天在PHP项目开发中遇到一个需求，去掉字符串中的最后一个字符原字符串1,2,3,4,5,6, 去掉最后一个字符","，最终结果为1,2,3,4,5,6 代码如下： $str = "1,2,3,4,5,6,"; $newstr = substr($str,0,strlen($str)-1); echo $newstr;
hadoop在linux上单机安装过程 _wy_ linux hadoop
1、安装JDK jdk版本最好是1.6以上，可以使用执行命令java -version查看当前JAVA版本号，如果报命令不存在或版本比较低，则需要安装一个高版本的JDK，并在/etc/profile的文件末尾，根据本机JDK实际的安装位置加上以下几行： export JAVA_HOME=/usr/java/jdk1.7.0_25
JAVA进阶----分布式事务的一种简单处理方法无量多系统交互分布式事务
每个方法都是原子操作：提供第三方服务的系统，要同时提供执行方法和对应的回滚方法 A系统调用B,C,D系统完成分布式事务 =========执行开始======== A.aa(); try { B.bb(); } catch(Exception e) { A.rollbackAa(); } try { C.cc(); } catch(Excep
安墨移动广告：移动DSP厚积薄发引领未来广告业发展命脉矮蛋蛋 hadoop 互联网
　　“谁掌握了强大的DSP技术，谁将引领未来的广告行业发展命脉。”2014年，移动广告行业的热点非移动DSP莫属。各个圈子都在纷纷谈论，认为移动DSP是行业突破点，一时间许多移动广告联盟风起云涌，竞相推出专属移动DSP产品。　　到底什么是移动DSP呢? 　　DSP(Demand-SidePlatform)，就是需求方平台，为解决广告主投放的各种需求，真正实现人群定位的精准广
myelipse设置 alafqq IP
在一个项目的完整的生命周期中，其维护费用，往往是其开发费用的数倍。因此项目的可维护性、可复用性是衡量一个项目好坏的关键。而注释则是可维护性中必不可少的一环。注释模板导入步骤安装方法：打开eclipse/myeclipse 选择 window-->Preferences-->JAVA-->Code-->Code
java数组百合不是茶 java数组
java数组的声明创建初始化； java支持C语言数组中的每个数都有唯一的一个下标一维数组的定义声明： int[] a = new int[3];声明数组中有三个数int[3] int[] a 中有三个数，下标从0开始，可以同过for来遍历数组中的数
javascript读取表单数据 bijian1013 JavaScript
利用javascript读取表单数据，可以利用以下三种方法获取： 1、通过表单ID属性：var a = document.getElementByIdx_x_x("id"); 2、通过表单名称属性：var b = document.getElementsByName("name"); 3、直接通过表单名字获取：var c = form.content.
探索JUnit4扩展：使用Theory bijian1013 java JUnit Theory
理论机制（Theory）一.为什么要引用理论机制（Theory）当今软件开发中，测试驱动开发（TDD — Test-driven development）越发流行。为什么 TDD 会如此流行呢？因为它确实拥有很多优点，它允许开发人员通过简单的例子来指定和表明他们代码的行为意图。 TDD 的优点： &nb
[Spring Data Mongo一]Spring Mongo Template操作MongoDB bit1129 template
什么是Spring Data Mongo Spring Data MongoDB项目对访问MongoDB的Java客户端API进行了封装，这种封装类似于Spring封装Hibernate和JDBC而提供的HibernateTemplate和JDBCTemplate，主要能力包括 1. 封装客户端跟MongoDB的链接管理 2. 文档-对象映射，通过注解:@Document(collectio
【Kafka八】Zookeeper上关于Kafka的配置信息 bit1129 zookeeper
问题： 1. Kafka的哪些信息记录在Zookeeper中 2. Consumer Group消费的每个Partition的Offset信息存放在什么位置 3. Topic的每个Partition存放在哪个Broker上的信息存放在哪里 4. Producer跟Zookeeper究竟有没有关系？没有关系！！！ //consumers、config、brokers、cont
java OOM内存异常的四种类型及异常与解决方案 ronin47 java OOM 内存异常
　OOM异常的四种类型：　　　　　一：　StackOverflowError ：通常因为递归函数引起（死递归，递归太深）。-Xss 128k 一般够用。　二：　out Of memory: PermGen Space：通常是动态类大多，比如web 服务器自动更新部署时引起。-Xmx
java-实现链表反转-递归和非递归实现 bylijinnan java
20120422更新：对链表中部分节点进行反转操作，这些节点相隔k个： 0->1->2->3->4->5->6->7->8->9 k=2 8->1->6->3->4->5->2->7->0->9 注意1 3 5 7 9 位置是不变的。解法：将链表拆成两部分： a.0-&
Netty源码学习-DelimiterBasedFrameDecoder bylijinnan java netty
看DelimiterBasedFrameDecoder的API，有举例：接收到的ChannelBuffer如下： +--------------+ | ABC\nDEF\r\n | +--------------+ 经过DelimiterBasedFrameDecoder(Delimiters.lineDelimiter())之后，得到： +-----+----
linux的一些命令 -查看cc攻击-网口ip统计等 hotsunshine linux
Linux判断CC攻击命令详解 2011年12月23日 ⁄ 安全 ⁄ 暂无评论查看所有80端口的连接数 netstat -nat|grep -i '80'|wc -l 对连接的IP按连接数量进行排序 netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n 查看TCP连接状态 n
Spring获取SessionFactory ctrain sessionFactory
String sql = "select sysdate from dual"; WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext(); String[] names = wac.getBeanDefinitionNames(); for(int i=0; i&
Hive几种导出数据方式 daizj hive 数据导出
Hive几种导出数据方式 1.拷贝文件如果数据文件恰好是用户需要的格式，那么只需要拷贝文件或文件夹就可以。 hadoop fs –cp source_path target_path 2.导出到本地文件系统 --不能使用insert into local directory来导出数据，会报错 --只能使用
编程之美 dcj3sjt126com 编程 PHP 重构
我个人的 PHP 编程经验中，递归调用常常与静态变量使用。静态变量的含义可以参考 PHP 手册。希望下面的代码，会更有利于对递归以及静态变量的理解 header("Content-type: text/plain"); function static_function () { static $i = 0; if ($i++ < 1
Android保存用户名和密码 dcj3sjt126com android
转自：http://www.2cto.com/kf/201401/272336.html 我们不管在开发一个项目或者使用别人的项目，都有用户登录功能，为了让用户的体验效果更好，我们通常会做一个功能，叫做保存用户，这样做的目地就是为了让用户下一次再使用该程序不会重新输入用户名和密码，这里我使用3种方式来存储用户名和密码 1、通过普通的txt文本存储 2、通过properties属性文件进行存
Oracle 复习笔记之同义词 eksliang Oracle 同义词 Oracle synonym
转载请出自出处：http://eksliang.iteye.com/blog/2098861 1.什么是同义词同义词是现有模式对象的一个别名。概念性的东西，什么是模式呢？创建一个用户，就相应的创建了一个模式。模式是指数据库对象，是对用户所创建的数据对象的总称。模式对象包括表、视图、索引、同义词、序列、过
Ajax案例 gongmeitao Ajax jsp
数据库采用Sql Server2005 项目名称为:Ajax_Demo 1.com.demo.conn包 package com.demo.conn; import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException; //获取数据库连接的类public class DBConnec
ASP.NET中Request.RawUrl、Request.Url的区别 hvt .net Web C#asp.net hovertree
如果访问的地址是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree%3C&n=myslider#zonemenu那么Request.Url.ToString() 的值是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree<&
SVG 教程（七）SVG 实例，SVG 参考手册天梯梦 svg
SVG 实例在线实例下面的例子是把SVG代码直接嵌入到HTML代码中。谷歌Chrome，火狐，Internet Explorer9，和Safari都支持。注意：下面的例子将不会在Opera运行，即使Opera支持SVG - 它也不支持SVG在HTML代码中直接使用。 SVG 实例 SVG基本形状一个圆矩形不透明矩形一个矩形不透明2 一个带圆角矩
事务管理 luyulong java spring 编程事务
事物管理 spring事物的好处为不同的事物API提供了一致的编程模型支持声明式事务管理提供比大多数事务API更简单更易于使用的编程式事务管理API 整合spring的各种数据访问抽象 TransactionDefinition 定义了事务策略 int getIsolationLevel()得到当前事务的隔离级别 READ_COMMITTED
基础数据结构和算法十一：Red-black binary search tree sunwinner Algorithm Red-black
The insertion algorithm for 2-3 trees just described is not difficult to understand; now, we will see that it is also not difficult to implement. We will consider a simple representation known
centos同步时间 stunizhengjia linux 集群同步时间
做了集群，时间的同步就显得非常必要了。以下是查到的如何做时间同步。在CentOS 5不再区分客户端和服务器，只要配置了NTP，它就会提供NTP服务。 1)确认已经ntp程序包： # yum install ntp 2)配置时间源（默认就行，不需要修改） # vi /etc/ntp.conf server pool.ntp.o
ITeye 9月技术图书有奖试读获奖名单公布 ITeye管理员 ITeye
ITeye携手博文视点举办的9月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 9月试读活动回顾：http://webmaster.iteye.com/blog/2118112本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：《NFC：Arduino、Andro