收藏闪存小组博问

freedomAndWind

园龄：4年4个月粉丝：13关注：9

📂java
🔖java
2021-12-27 11:35阅读: 42评论: 0推荐: 0

集合

1.集合概念

对象的容器,定义了多个对象进行操作的常用方法.可实现数组的功能.

集合和数组区别

  1. 数组长度固定,集合长度不固定

  2. 数组可以存储基本类型和引用类型,集合只能存储引用类型

2.Collection父接口

  1. Collection特点:代表一组任意类型的对象,无序、无下标、不能重复。
  2. 方法：
    • boolean add(Object obj)//添加一个对象
    • boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中.
    • void clear()//清空此集合中的所有对象.
    • boolean contains(Object o)//检查此集合中是否包含o对象
    • boolean equals(Object o)//比较此集合是否与指定对象相等
    • boolean isEmpty()//判断此集合是否为空
    • boolean remove(Object o)//在此集合中移除o对象
    • int size()//返回此集合中的元素个数
    • Object toArray()//将此集合转换成数组List子接口

Collection接口的使用

package Aggregate.Collection;

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

/*
Collection接口的使用
(1)添加元素
(2)删除元素
(3)遍历元素
(4)判断
 */
public class Demo01 {
    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.toString());
//        (2)删除元素
//        collection.remove("榴莲");
//        collection.clear();
//        System.out.println("删除之后"+collection.size());
//        (3)遍历元素
        //3.1使用增强for
        System.out.println("--3.1使用增强for--");
        for (Object object:collection) {
            System.out.println(object);
        }
        //3.2使用迭代器(迭代器专门用来遍历集合的一种方式)
        //hsaNext();有没有下一个元素
        //next();获取下一个元素
        //remove();删除当前元素
        System.out.println("--3.2使用迭代器--");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s= (String) it.next();
            System.out.println(s);
            //不能使用collection删除方法;
            //collection.remove(s);
            //it.remove();
        }
        System.out.println("元素个数"+collection.size());
//        (4)判断
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.isEmpty());
    }
}

collection的使用:保存学生信息

package Aggregate.Collection;

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

/*
collection的使用:保存学生信息
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建Collection对象
        Collection collection = new ArrayList();
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("张无忌", 18);
        Student s3 = new Student("王二", 22);
        //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遍历
        //3.1增强for
        for (Object object:collection) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        //3.2迭代器:hsaNext();next();remove();迭代过程中不能使用collection的删除方法
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s  = (Student) it.next();
            System.out.println(s.toString());
        }
        //4判断
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.List子接口

  • 特点:有序.、有下标、元素可以重复。
  • 方法：
    • void add(int index,Object o)//在index文职插入对象o
    • boolean addAll(int index,Collection c)//将一个集合中的元素添加到此集合中的index位置
    • Object get(int index)//返回集合中指定位置的元素
    • List subList(int fromIndex,int toIndex)//返回fromIndex和toIndex之间的集合元素(含头不含尾)

List子接口

package Aggregate.List;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/*
List子接口的特点
特点:1.有序、有下标，2.可以重复
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList<>();
        //1添加元素
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //2删除元素
//        list.remove("苹果");
//        list.remove(0);
//        System.out.println("删除之后："+list.size());
//        System.out.println(list.toString());
        //3遍历元素
        //3.1使用for遍历
        System.out.println("--3.1使用for遍历--");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.2使用增强for
        System.out.println("--3.2使用增强for--");
        for (Object o : list) {
            System.out.println(o);
        }
        //3.3使用迭代器
        Iterator it = list.iterator();
        System.out.println("--3.3使用迭代器--");
        while (it.hasNext()){
            System.out.print(it.next());
        }
        //3.4使用列表迭代器，和Iterator的区别，ListIterator可以向前或向后遍历、添加、删除、修改元素
        ListIterator lit = list.listIterator();
        System.out.println("--3.4使用列表迭代器从前往后--");
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("--3.4使用列表迭代器从后往前--");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //4判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        //5获取位置
        System.out.println(list.indexOf("华为"));
    }
}

List的使用

package Aggregate.List;

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

/*
List的使用
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
        //添加数字数据
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //2删除操作
        //list.remove(0);
        list.remove((Object)20);
        System.out.println("删除之后:"+list.size());
        System.out.println(list.toString());

        //3补充方法sublist：返回了集合,含头不含尾
        List sublist = list.subList(1, 3);
        System.out.println(sublist.toString());
    }
}

List实现类

  • ArrayList[重点]:

    • 数组结构实现,查询快、增删慢；

    • JDK1.2版本，运行效率快、线程不安全。

    • 源码分析：DEFAUT_CAPACITY=10;默认容量,注意：如果没有向集合中添加任何元素，容量是0,添加一个元素之后容量就是10了；每次扩容大小大欧式原来的1.5倍

      elementData;存放元素的数组

      size；实际元素个数

      add();添加元素

  • Vector：

    • 数组结构实现，查询快、增删慢；
    • JDK1.0版本，运行效率慢、线程安全。

  • LinkedList：

    • 链表结构实现，增删块，查询慢。

ArrayList的使用

package Aggregate.List;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/*
ArrayList的使用
存储结构：数组，查找遍历速度快，增删慢
 */
public class arrayList {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList<>();
        //1添加元素
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());
        //2删除元素
//        arrayList.remove(s1);
//        arrayList.remove(new Student("刘德华",20));//equals(this==ob)
//        System.out.println("删除之后："+arrayList.size());

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

        //3.2列表迭代器
        ListIterator lit = arrayList.listIterator();
        System.out.println("--3.2使用列表迭代器正序--");
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }
        System.out.println("--3.2使用列表迭代器逆序--");
        while (lit.hasPrevious()){
            Student s = (Student) lit.previous();
            System.out.println(s.toString());
        }

        //4判断
        System.out.println(new Student("梁朝伟",18));//对Student进行了重写,就可以通过这种方式删除
        System.out.println(arrayList.isEmpty());

        //5查找
        System.out.println(arrayList.indexOf(new Student("梁朝伟",18)));
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

Vector的使用

package Aggregate.List;

import java.util.Enumeration;
import java.util.Vector;

/*
演示Vector集合的使用
存储结构：数组
 */
public class vector {
    public static void main(String[] args) {
        //创建几个
        Vector vector = new Vector<>();
        //1添加元素
        vector.add("草莓");
        vector.add("芒果");
        vector.add("西瓜");
        System.out.println("元素个数："+vector.size());

        //2删除
//        vector.remove(0);
//        vector.remove("西瓜");
//        vector.clear();

        //3遍历
        //使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            String o = (String) en.nextElement();
            System.out.println(o);
        }

        //4判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());

        //5Vector其他方法
        //firsetElement、lastElement、element();
    }
}

LinkedList的使用

package Aggregate.List;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/*
LinkedList的使用
存储结构：双向链表
 */
public class linkedList {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList= new LinkedList();
        //1添加元素
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList.toString());
        //2删除
//        linkedList.remove(new Student("刘德华",20));
//        System.out.println("删除之后："+linkedList.toString());
//        linkedList.clear();

        //3遍历
        //3.1for遍历
        System.out.println("--3.1for遍历--");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //3.2增强for
        System.out.println("--3.2增强for--");
        for (Object o : linkedList) {
            Student s = (Student)o;
            System.out.println(o);
        }
        //3.3使用迭代器
        Iterator it = linkedList.iterator();
        System.out.println("--3.3使用迭代器--");
        while (it.hasNext()){
            Student s= (Student) it.next();
            System.out.println(s.toString());
        }
        //3.4使用列表迭代器
        System.out.println("--3.4使用列表迭代器--");
        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(s2));
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

泛型

  • Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
  • 常见形式有泛型类、泛型接口、泛型方法。
  • 语法：<T,....>T称为类型占位符，表示一种引用类型。
  • 好处：
    • 提高代码的重用性
    • 防止类型转换异常，提高代码的安全性

泛型类

package Aggregate.MyGeneric;
/*
泛型类
语法：类名<T>
T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
 */
public class Demo01<T>{
    //使用泛型T
    //1创建变量
    T t;

    //2泛型作为方法的参数
    public  void show(T t){
        //不能直接new对象(实例化)
        System.out.println(t);
    }
    //3使用泛型作为方法的返回值
    public  T getT(){
        return t;
    }
}

泛型接口

package Aggregate.MyGeneric;
/*
泛型接口
语法:接口名<T>
注意:不能泛型静态常量
 */
public interface interface01<T> {
    String name = "张三";

    T server(T t);
}

实现接口

两种方法:

1.在实现接口的时候确定泛型类

package Aggregate.MyGeneric;

public class InterfaceImpl implements interface01<String> {

    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

2.实现类也是一个泛型,在使用时确定泛型类

package Aggregate.MyGeneric;

public class Interface02<T> implements interface01<T>{

    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

泛型方法

package Aggregate.MyGeneric;
/*
泛型方法
语法:<T>返回值类型
 */
public class Method {
    //泛型方法
    public <T> T  show(T t){
        System.out.println("泛型方法:"+t);
        return t;
    }
}

泛型测试类

package Aggregate.MyGeneric;

public class TestGeneric {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意:1泛型只能使用引用类型,2不同泛型类型对象之间不能相互赋值
        Demo01<String> demo01 = new Demo01<String>();
        //1.创建变量
        demo01.t="hello";
        System.out.println(demo01.t);
        //2泛型作为方法的参数
        demo01.show("大家好，加油");
        //3使用泛型作为方法返回值
        String string = demo01.getT();

        Demo01<Integer> demo012= new Demo01<>();
        demo012.t=100;
        demo012.show(200);
        Integer integer = demo012.getT();
		//泛型接口
        //泛型接口1
        InterfaceImpl impl = new InterfaceImpl();
        impl.server("xxxx");
		//泛型接口2
        Interface02<Integer> impl2 = new Interface02<>();
        impl2.server(2000);

        //泛型方法
        Method method = new Method();
        method.show("中国加油");
        method.show(200);
        method.show(3.14);
    }
}

泛型集合

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

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

public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("xxx");
        arrayList.add("yyy");
//        arrayList.add(10);
//        arrayList.add(20);
        for (String string : arrayList) {
            System.out.println(string);
        }
        ArrayList<Student> arrayList2 = new ArrayList<Student>();
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList2.add(s1);
        arrayList2.add(s2);
        arrayList2.add(s3);
        Iterator<Student> it = arrayList2.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.toString());
        }
    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
        @Override
    public boolean equals(Object obj) {
        //1判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //2判断是否为空
        if (obj==null){
            return false;
        }
        //3判断是否是Student类型
        if (obj instanceof Student){
            Student s = (Student) obj;
            //4比较属性
            if ((this.name.equals(s.getName())&&this.age==s.getAge())){
                return true;
            }
        }
        //5不满足条件返回false
        return false;
    }
}

通配符

为了表示各种泛型List的父类,可以使用类型通配符

  • 类型通配符:<?>
  • List<?>:表示元素类型未知的List,他的元素可以匹配任何的类型
  • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类,可以使用类型通配符的上限

  • 类型通配符上限:<? extends 类型>
  • List <? extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限

  • 类型通配符下限:<? super 类型>
  • List<? supr Number>:它表示的类型是Number或者其父类型
package Aggregate.MyGeneric;

import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList;

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

/*
    类型通配符<?>
        list<?>,表示元素类型未知的list,它的元素可以匹配任何的类型
        这种带通配符的List仅表示它是各种类型list的父类,并不能把元素添加到其中

    类型通配符上限,<? extends 类型>
        list<? extends Number>:它表示的类型是Number或者其子类型

    类型通配符下限,<? super 类型>
        list<? super Number>:它表示的类型是Number或者其父类型
*/
public class GenericWildcard {
    public static void main(String[] args) {
        //类型通配符:<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");
        //类型通配符上限,<? extends 类型>
//        List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符下限:<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9 = new ArrayList<Integer>();


    }
}

可变参数

可变参数又称参数个数可变,作用方法的形参出现,那么方法参数个数就是可变的了

  • 格式:修饰符 返回值类型 方法名(数据类型... 变量名){}
  • 范例:public static int sum(int... a){}

可变参数注意事项

  • 这里的变量其实是一个数组
  • 如果一个方法有多个参数,包含可变参数,可变参数要放在最后
package Aggregate.MyGeneric;

public class ArgsDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
       System.out.println(sum(10,20,30,40));
        //可变参数的输出
        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
    }
    /*
    public static int sum (int b,int... a){}//注意:一个方法有多个参数,且包含可变参数,可变参数要放在最后.
     */
    public static int sum(int... a){
//        System.out.println(a);
//        return 0;
        int sum = 0;
        for (int i: a) {
            sum+=1;
        }
        return sum;
    }
    
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d){
        return a+b+c+d;
    }
}

可变参数的使用

  • Arrays工具类中有一个静态方法:
    • public static <T> List<T> asList(T... a):返回有指定数组支持的固定大小的列表
    • 返回的集合不能做增删操作,可以做修改操作
  • List接口中有一个静态方法:
    • public static <E> List<E> of(E... elements):返回包含任意数量元素的不可变列表
    • 返回的集合不能做增删改操作
    • 注意:jdk1.8没有这个特性
  • Set接口中有一个静态方法:
    • public static<E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合
    • 在给元素的时候,不能给重复的元素
    • 返回的集合不能做增删操作,没有修改的方法

Set集合

Set子接口

  • 特点:无序、无下标、元素不可重复
  • 方法：全部继承自Collection中的方法
package Aggregate.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
测试Set接口的使用
特点:1.无序、没有下标。2.不能重复。
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1添加数据
        set.add("苹果");
        set.add("华为");
        set.add("小米");
        System.out.println("数据个数"+set.size());
        System.out.println(set.toString());
        //2删除
        set.remove("小米");
        System.out.println(set.toString());
        //3遍历[重点]
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : set) {
            System.out.println(string);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println("华为");
        System.out.println(set.isEmpty());
    }
}

Set实现类

  • HashSet[重点]:
    • 基于HashCode计算元素存放位置
    • 当存入元素的哈希码相同时,会调用equals进行确认,如结果为true,则拒绝后者存入
  • TreeSet
    • 基于排列顺序实现元素不重复
    • 实现了SortedSet接口,对集合元素自动排序
    • 元素对象的类型必须实现Compareable接口,指定排序规则
    • 通过CompareTo方法确定是否为重复元素

HashSet的简单使用

package Aggregate.set;

import java.util.HashSet;
import java.util.Iterator;

/*
HashSet集合的使用
存储结构:哈希表(数组+链表+红黑树(jdk1.8后))
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet = new HashSet<>();
        //1添加元素
        hashSet.add("刘德华");
        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());
        //3遍历操作
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : hashSet) {
            System.out.println(string);
        }
        //3.2使用迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = hashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(hashSet.contains("郭富城"));
        System.out.println(hashSet.isEmpty());
    }
}

HashSet"进阶版"

package Aggregate.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;

/*
HashSet的使用
存储结构:哈希表(数组+链表+红黑树(jdk1.8后))
存储过程
(1)根据华顺从的,计算保存的位置,如果此位置为空,则直接保存;如果不为空,执行第二步
(2)可执行equals方法,如果equals方法为true,则认为是重复,否则,形成链表
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建集合
        HashSet<Person> persons = new HashSet<>();
        //1添加数据
        Person p1 = new Person("刘德华",20);
        Person p2 = new Person("林志玲",22);
        Person p3 = new Person("梁朝伟",25);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(new Person("梁朝伟",25));//当重写hashCode和equals此处就添加不进去了.

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

        //2删除操作
        persons.remove(p1);
        System.out.println("删除之后:"+persons.size());
        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (Person person : persons) {
            System.out.println(person.toString());
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<Person> it =persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(persons.contains(p1));
        System.out.println(persons.contains(new Person("林志玲",22)));
        System.out.println(persons.isEmpty());
    }
}

class Person {
    private String name;
    private int age;

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

    public Person() {
    }

    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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写hashCode和equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

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

TreeSet的简单使用

package Aggregate.set;

import java.util.Iterator;
import java.util.TreeSet;

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

        //2删除
        treeSet.remove("xyz");
        System.out.println("删除之后:"+treeSet.size());
        System.out.println(treeSet.toString());

        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (String string : treeSet) {
            System.out.println(string);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<String> it = treeSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(treeSet.ceiling("abc"));
    }
}

TreeSet的"进阶版"

package Aggregate.set;

import java.util.Iterator;
import java.util.TreeSet;
import java.util.Objects;

/*
TreeSet的使用
存储结构:红黑树
要求:元素必须要实现Comparable接口,在自定义比较规则;comparaTo()方法返回值为0,认为是重复元素
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建集合
        TreeSet<Person> persons = new TreeSet<>();
        //1添加元素
        Person p1 = new Person("xyz",20);
        Person p2 = new Person("hello",22);
        Person p3 = new Person("zhangsan",25);
        Person p4 = new Person("zhangsan",20);

        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(p1);
//        System.out.println("删除之后:"+persons.size());
        //3遍历
        //3.1增强for
        System.out.println("----3.1增强for----");
        for (Person person : persons) {
            System.out.println(person);
        }
        //3.2迭代器
        System.out.println("----3.2迭代器----");
        Iterator<Person> it = persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4判断
        System.out.println(persons.contains(new Person("zhangsan",20)));
    }
}
class Person  implements Comparable<Person>{
    private String name;
    private int age;

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

    public Person() {
    }

    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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写hashCode和equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    //先按姓名比,然后在按年龄比
    @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接口

package Aggregate.set;

import java.util.Comparator;
import java.util.TreeSet;

/*
TreeSet集合的使用
Comparator:实现定制比较(比较器)
 */
public class Demo06 {
    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("xyz",20);
        Person p2 = new Person("hello",22);
        Person p3 = new Person("zhangsan",25);

        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        System.out.println(persons.toString());
    }

}

Comparator接口"进阶版"

	package Aggregate.set;

import java.util.Comparator;
import java.util.TreeSet;

/*
要求:使用TreeSet集合实践字符串按照长度进行排序
helloworld zhang lisi wangwu beijing xian nanjing
Comparator接口实现定制比较
 */
public class Demo07 {
    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("helloworld");
        treeSet.add("pingguo");
        treeSet.add("lisi");
        treeSet.add("zhnagsan");
        treeSet.add("beijing");
        treeSet.add("cat");
        treeSet.add("nanjing");
        treeSet.add("xian");
        System.out.println(treeSet);
    }
}

Map集合

Map接口

  • 特点:用于存储任意键值对(Ket-Value),无序、无下标，键不可重复，值可重复
  • 方法：
    • V put(K key,V value)//将对象存入到集合中,关联键值.key重复则覆盖原值.
    • Object get(Object key)//根据键获取对应的值
    • Set<K> keySet() //返回所有key
    • Collection<V> values() //返回包含所有值得Collection集合.
package Aggregate.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map接口的使用
 * 特点:(1)存储键值对(2)键不能重复,值可重复(3)无序
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //1添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");

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

        //2删除
//        map.remove("usa");//通过删除key来达到删除目的
//        System.out.println("删除过后:"+map.size());

        //3遍历
        //3.1使用keySet();
        System.out.println("--keySet--");
        Set<String> keyset= map.keySet();//如果把for循环里面的keyset换成,map.keyset就可以把这个省略
        for (String key : keyset) {
            System.out.println(key+"----"+map.get(key));
        }
        //3.2使用entrySet()方法
        System.out.println("--entrySet--");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }

        //4判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));

    }
}

Map集合的实现类

HashMap[重点]

  • JDK1.2版本,线程不安全,运行效率快;允许用null作为key或是value

Hashtable:

  • JDK1.0版本,线程安全,运行效率慢;不允许null作为key或是value

Properties

  • Hashtable的子类,要求key和value都是String.通常用于配置文件的读取.

TreeMap

  • 实现了SortedMap接口(是Map的子接口),可以对key自动排序

总结:

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

Map接口的使用

package Aggregate.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map接口的使用
 * 特点:(1)存储键值对(2)键不能重复,值可重复(3)无序
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //1添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");

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

        //2删除
//        map.remove("usa");//通过删除key来达到删除目的
//        System.out.println("删除过后:"+map.size());

        //3遍历
        //3.1使用keySet();
        System.out.println("--keySet--");
        Set<String> keyset= map.keySet();//如果把for循环里面的keyset换成,map.keyset就可以把这个省略
        for (String key : keyset) {
            System.out.println(key+"----"+map.get(key));
        }
        //3.2使用entrySet()方法
        System.out.println("--entrySet--");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }

        //4判断
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));

    }
}

HashMap集合的使用

package Aggregate.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/*
HashMap集合的使用
存储结构:哈希表(数组+链表+红黑树)
使用key可hashCode和equals作为重复
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合
        HashMap<Studnt,String> studets = new HashMap<Studnt,String>();
        //1添加元素
        Studnt s1 = new Studnt("孙悟空",100);
        Studnt s2 = new Studnt("猪八戒",101);
        Studnt s3 = new Studnt("沙和尚",102);
        studets.put(s1,"北京");
        studets.put(s2,"上海");
        studets.put(s3,"杭州");
        studets.put(new Studnt("沙和尚",102),"杭州");
        System.out.println("元素个数:"+studets.size());
        System.out.println(studets.toString());
        //2删除元素
        studets.remove(s1);
        System.out.println("删除之后:"+studets.size());
        //3遍历
        //3.1使用keyset();
        System.out.println("--keyset--");
        for (Studnt key: studets.keySet()) {
            System.out.println(key.toString()+"==="+studets.get(key));
        };
        //3.2使用entrySet();
        System.out.println("--entrySet--");
        for (Map.Entry<Studnt,String> entry: studets.entrySet()) {
            System.out.println(entry.getKey()+"--"+entry.getKey());
        }
        //4判断
        System.out.println(studets.containsKey(s1));
        System.out.println(studets.containsValue("杭州"));
    }
}
class Studnt{
    private String name;
    private int stuNO;

    public Studnt() {
    }

    public Studnt(String name, int stuNO) {
        this.name = name;
        this.stuNO = stuNO;
    }

    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 "Studnt{" +
                "name='" + name + '\'' +
                ", stuNO=" + stuNO +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Studnt studnt = (Studnt) o;
        return stuNO == studnt.stuNO &&
                name.equals(studnt.name);
    }

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

TreeMap的使用

package Aggregate.map;

import java.util.Map;
import java.util.TreeMap;
import java.util.Objects;

/*
TreeMap的使用
存储结构:红黑树
 */
public class Demo03 {
    public static void main(String[] args) {
        //新建集合
        TreeMap<Studnt,String> treeMap = new TreeMap<Studnt,String>();
        //1添加元素
        Studnt s1 = new Studnt("孙悟空",100);
        Studnt s2 = new Studnt("猪八戒",101);
        Studnt s3 = new Studnt("沙和尚",102);
        treeMap.put(s1,"北京");
        treeMap.put(s2,"上海");
        treeMap.put(s3,"南京");
        System.out.println("元素个数:"+treeMap.size());
        System.out.println(treeMap.toString());
        //2删除
        treeMap.remove(s3);
        System.out.println("删除之后:"+treeMap.toString());
        //3遍历
        //3.1使用keyset();
        System.out.println("--keyset--");
        for (Studnt key: treeMap.keySet()) {
            System.out.println(key+"---"+treeMap.get(key));
        }
        //3.2使用entryset();
        System.out.println("--entryset--");
       for (Map.Entry<Studnt,String> entry: treeMap.entrySet()){
           System.out.println(entry.getKey()+"----"+entry.getValue());
       }
       //4判断
        System.out.println(new Studnt("沙和尚",102));

    }
}

class Studnt implements Comparable<Studnt>{
    private String name;
    private int stuNO;

    public Studnt() {
    }

    public Studnt(String name, int stuNO) {
        this.name = name;
        this.stuNO = stuNO;
    }

    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 "Studnt{" +
                "name='" + name + '\'' +
                ", stuNO=" + stuNO +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Studnt studnt = (Studnt) o;
        return stuNO == studnt.stuNO &&
                name.equals(studnt.name);
    }

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


    @Override
    public int compareTo(Studnt o) {
        int n1 =this.name.compareTo(o.getName());
        int n2 =this.stuNO-o.getStuNO();
        return n2;
    }
}

Collections工具类

  • 概念:集合工具类,定义除了存取以外的集合常用方法
  • 方法:
    • public static void reverse(List<?> list)//反转集合中元素的排序
    • public static void shuffle(List<?> kist)//随机重置集合元素的顺序
    • public static void sort(LIst<?> list)//升序排序(元素类型必须实现Comparable接口)
package Aggregate.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/*
演示Collections工具类的使用
 */
public class Demo04 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(5);
        list.add(12);
        list.add(30);
        list.add(6);
        //sort排序
        System.out.println("排序之前:"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后:"+list.toString());
        //binarySearch二分查找
        int i = Collections.binarySearch(list,13);
        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.toString());
        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println("打乱之后:"+list.toString());

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

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

        System.out.println(list1);

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

本文作者：freedomAndWind

本文链接：https://www.cnblogs.com/linjiangplus/p/15735666.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   freedomAndWind  阅读(42)  评论(0)  编辑  收藏  举报
编辑推荐：
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae
评论
收藏
关注
推荐
深色
回顶
收起
  1. 1 Meet Fi9江澈,果妹
Meet - Fi9江澈,果妹
00:00 / 00:00
An audio error has occurred.

作词 : Fi9江澈

作曲 : Fi9江澈

她不是很瘦 她的个子也够不高

她不是很瘦 她的个子也够不高

她有时很逗 有时候 她也够SAO

每次她化完妆盯着问我 我会说她很丑

但每次离开的时候 我们互相 谁都不肯走

她爱吃粉丝的醋 也爱跟我 生气

她做傻事的时候 也都是和我会有争议

她不化妆的时候 我会刻意的说她很漂亮

总爱素颜的时候 去和别的女生去较量

她喜欢我性格的好 和行为上的屌丝

喜欢我的城市还有运河街道边的小吃

她有时很任性 莫名的跟我吵架

每次她耍小性子 也都会被我都一顿的好骂

她叫我玩游戏 我总故意不跟她玩

每次吵架的时候 总骂我是个渣男

她会讨好我爸妈 也会买礼物给悄悄

每次 卖萌 我也心领神会的笑笑

HOOK：街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

她一直都很敏感 总是常常怕我失去

她不知道 在我心里 她是我写下的诗句

她会在心情不好的时候 跟朋友去酗酒

大醉之后会说以后的路 她会陪着我去走

总爱问我分手了 会不会像以前 那样去对她

提些奇怪的问题 手机屏保为什不是她

说我对你这么好 你竟然想要跟我分手

哎 这个贱男人 我就知道 你可真狗

这个不可理喻的女人让我又爱又恨

生病的时候让人心疼 看起来又乖又笨

就算吵架的时候 不爱跟你讲道理

在人群中我依然 一眼就能找到你

我可以为 她遮风为她挡雨

也可以陪她一整天 依偎在我房里

还记得第一次见她 是我 第一次的演出

还记得她也曾在 夜里 为我闭着眼哭

HOOK：街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

混音：Fi9江澈

混音：Fi9江澈

统筹：杨冰

OP:汇音文化