java基础语法day30_集合

最新推荐文章于 2024-09-15 15:39:28 发布

只会写bug的菜鸡

最新推荐文章于 2024-09-15 15:39:28 发布

阅读量184

点赞数

分类专栏： java 笔记

本文链接：https://blog.csdn.net/mzj15101229871/article/details/115288884

版权

笔记同时被 2 个专栏收录

46 篇文章 5 订阅

订阅专栏

java

28 篇文章 0 订阅

订阅专栏

p696 Map接口常用方法

在这里插入图片描述

静态内部类

package com.bjpowernode.day24.Collection;

public class MyClass {

    //声明一个静态内部类
    public static class InnerClass{

        public static void m1(){
            System.out.println("静态内部类的m1方法执行");
        }
    }

    public static void main(String[] args) {

        //调用静态内部类的静态方法
        MyClass.InnerClass.m1();
    }
}

在这里插入图片描述

p697 Map接口常用方法

package com.bjpowernode.day24.Collection;

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

/**
 * 1、Map和Collection没有继承关系
 * 2、键值对
 *         key和value都是引用数据类型
 *         key和value都是存储对象的内存地址
 *         key起到主导作用，value是key的附属品
 */
public class MapTestTest01 {
    public static void main(String[] args) {

        //创建Map集合对象
        Map<Integer,String> map = new HashMap<>();

        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");


        //get获取指定key值对应的VALUE
        String value= map.get(3);
        System.out.println(value);

        //获取键值对的数量
        System.out.println("键值对的数量是"+map.size());

        //通过Key删除key-value
        map.remove(3);
        System.out.println("键值对的数量是"+map.size());



        //判断是否包含某个key
        //contains方法底层都是调用equals方法比对的，所以自定义的类型需要重写equals方法
        System.out.println(map.containsKey(4));

        //判断是否包含某个value
        System.out.println(map.containsValue("zhaoliu"));


        //获取所有的value
        System.out.println(map.values());

        //获取所有的key
        System.out.println(map.keySet());

        //清空
        map.clear();
        System.out.println("键值对的数量是"+map.size());

        //判断Set是否为空
        System.out.println(map.isEmpty());




    }


}

p698 遍历Map集合

package com.bjpowernode.day24.Collection;

//Map集合的遍历

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

public class MapTest02 {
    public static void main(String[] args) {

        //第一种方法，先获取所有的key，通过遍历key，来便利value

        Map<Integer,String> map = new HashMap<>();

        map.put(1,"hello");
        map.put(6,"kitty");
        map.put(4,"wife");
        map.put(3,"hahaha");

        //遍历Map集合，获取所有的Key，所有的key是一个Interger类型的Set集合
        Set<Integer> keys = map.keySet();
//        System.out.println(set);
        //遍历Set，通过Set获取value


        //通过迭代器
//        Iterator<Integer> it = keys.iterator();
//
//        while(it.hasNext()){
//           Integer key = it.next();
//            System.out.println(map.get(key));
//        }
        //通过foreach
        for (Integer key: keys){
            System.out.println(key + "="+map.get(key));
        }
        //第二种方法：Set<Map.Entry<K,V>> entrySet()
    }
}

p699 遍历Map集合的第二种方式

在这里插入图片描述

      //第二种方法：Set<Map.Entry<K,V>> entrySet()
        //返回一个set集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();

        //遍历set集合，每一次取出一个Node
        //使用迭代器遍历
//        Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
//
//        while(it2.hasNext()){
//            Map.Entry<Integer,String> entry = it2.next();
            System.out.println(entry);
//            Integer key = entry.getKey();
//            String value = entry.getValue();
//            System.out.println(key+"="+value);
//        }

        //使用增强for循环
        for (Map.Entry<Integer,String> entry:set){
//            System.out.println(entry);//
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }

p700 哈希表数据结构1

在这里插入图片描述

p701 哈希表数据结构2

在这里插入图片描述

p702同时重写HashCode和equals方法1

在这里插入图片描述

p703同时重写HashCode和equals方法2

在这里插入图片描述

package com.bjpowernode.day24.Collection.bean;

import java.util.HashSet;
import java.util.Set;

public class HashMaptest02 {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan");
        Student stu2 = new Student("zhangsan");

        //重写equals方法之前，比较内存地址，返回flase
        //System.out.println(stu1.equals(stu2));//false

        //重写equals方法之后
        System.out.println(stu1.equals(stu2));

        //stu1的HashCode是多少,重写HashCode方法之前，stu1和stu2的哈希值是不一样的
        System.out.println("stu1的Hashcode是"+stu1.hashCode());//2129789493
        System.out.println("stu2的Hashcode是"+stu2.hashCode());//1313922862

        //此时stu1.equals(stu2)已经是true了，表示stu1和stu2是相等的，那么往HashSet中放的话，按理说只能放进去一个，

        Set<Student> students = new HashSet<>();

        students.add(stu1);
        students.add(stu2);

        System.out.println("集合长度是"+students.size());//按理说这个结果是1，但是真实结果是2
    }
}

p704 同时重写HashCode和equals方法3

在这里插入图片描述

package com.bjpowernode.day24.Collection.bean;

import java.util.HashSet;
import java.util.Set;

public class HashMaptest02 {
    public static void main(String[] args) {
        Student stu1 = new Student("zhangsan");
        Student stu2 = new Student("zhangsan");

        //重写equals方法之前，比较内存地址，返回flase
        //System.out.println(stu1.equals(stu2));//false

        //重写equals方法之后
        System.out.println(stu1.equals(stu2));

        //stu1的HashCode是多少,重写HashCode方法之前，stu1和stu2的哈希值是不一样的
        System.out.println("stu1的Hashcode是"+stu1.hashCode());//2129789493————重写HashCode之后》-1432604525
        System.out.println("stu2的Hashcode是"+stu2.hashCode());//1313922862————重写HashCode之后》-1432604525

        //此时stu1.equals(stu2)已经是true了，表示stu1和stu2是相等的，那么往HashSet中放的话，按理说只能放进去一个，

        Set<Student> students = new HashSet<>();

        students.add(stu1);
        students.add(stu2);

        //重写equals方法吗，但是HashCode方法没重写
        //System.out.println("集合长度是"+students.size());//按理说这个结果是1，但是真实结果是2，显然不符合HashSet集合特点。怎么办？

        //同时重写equals和HashCode方法
        System.out.println("集合长度是"+students.size());//同时重写equals和HashCode方法之后，返回1
    }
}

p705 java8对于HashMap的改进

在这里插入图片描述

单链表中的元素大于8个，单链表结构转为红黑树数据结构
单链表中的元素小于6个，红黑树结构转为单链表结构

p706 回顾上午内容

Hash值相同的话一定在通过一个链表上
在同一个链表上的Hash值不一定一样，有可能发生哈希碰撞

1、掌握HashMap的常用方法
2、会创建、添加、遍历HashMap
3、同时重写equals和HashCode方法
4、HashMap扩容之后的容量是原容量的2倍

p707 HashMap和HashTable的区别

HashMap	HashTable
Key和Value都可以为null	key和value都不能为null
非线程安全	线程安全
使用较多	虽然是线程安全，但是线程安全有别的处理方法，使用较少
默认容量16	默认容量11
扩容方式：原容量*2	原容量*2+1

在这里插入图片描述

p708 属性类Properties类

package com.bjpowernode.day24.Collection;

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class PropertiesTest01 {
    public static void main(String[] args) {

        //创建properties对象
        Properties properties = new Properties();

        //存,此处的set方法调用的是Hash Map的put方法
        properties.setProperty("url","jdbc:mysql//localhost：3306/bjpowernode");
        properties.setProperty("username","root");
        properties.setProperty("driver","zhangsan");
        properties.setProperty("password","123456");

        //取，使用Key来取
        String url = properties.getProperty("url");
        String driver = properties.getProperty("username");
        String username = properties.getProperty("driver");
        String password = properties.getProperty("password");

        System.out.println(url);
        System.out.println(driver);
        System.out.println(username);
        System.out.println(password);
    }
}

p709 演示TreeSet对String是可排序的

package com.bjpowernode.day24.Collection;

import java.util.TreeSet;

public class TreeSetTest02 {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();

        treeSet.add("zhangsan");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("zhangsi");
        treeSet.add("wangliu");

        for (String s : treeSet){
            System.out.println(s);
            //按照字典顺序升序
        }
        TreeSet<Integer> treeSet2 = new TreeSet<>();
        treeSet2.add(100);
        treeSet2.add(300);
        treeSet2.add(400);
        treeSet2.add(900);
        treeSet2.add(4500);
        treeSet2.add(800);
        treeSet2.add(10);

        for (Integer i : treeSet2){
            System.out.println(i);
        }
    }
}

p710 TreeSet无法对自定义类型排序

在这里插入图片描述

理解下面注释代码错误的原因
Person类没有实现java.lang.Comparable接口，导致无法排序

package com.bjpowernode.day24.Collection;


/**
 * 对于自定义的类型来说，TreeSet可以排序吗？
 * java.lang.ClassCastException: class com.bjpowernode.day24.Collection.
 *  Person cannot be cast to class java.lang.Comparable
 * import java.util.TreeSet;
 */


public class TreeSetTest03 {
    public static void main(String[] args) {
        Person person1 = new Person(20);
//        System.out.println(person1);
        Person person2 = new Person(45);
        Person person3 = new Person(23);
        Person person4 = new Person(22);


//        TreeSet<Person> persons = new TreeSet<>();

//        persons.add(person1);
//        persons.add(person2);
//        persons.add(person3);
//        persons.add(person4);
//
//        //遍历
//        for(Person p : persons ){
//            System.out.println(p);
//        }
    }
}
class Person{
    int age;

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

    @Override
    public String toString() {
        return "Person[age="+age+"]";
    }
}

p711 自定义类型实现Comparable接口

package com.bjpowernode.day24.Collection;

import java.util.TreeSet;

public class TreeSetTest04 {
    public static void main(String[] args) {
        Customer c1 = new Customer(23);
        Customer c2 = new Customer(67);
        Customer c3 = new Customer(45);
        Customer c4 = new Customer(34);

        TreeSet<Customer> customers = new TreeSet<>();

        customers.add(c1);
        customers.add(c2);
        customers.add(c3);
        customers.add(c4);

        //遍历
        for(Customer c : customers){
            System.out.println(c);
        }
    }
}


class Customer implements Comparable<Customer>{//实现比较的方法
    private int age;

    public Customer(int age) {
        this.age = age;
    }

    @Override//重写比较规则
    public int compareTo(Customer o) {//c1.compareTo(c2);
        //上面注释中的c1就是this指针，c2就是参数o
        //比较两个年龄，先获取年龄
        int age1 = this.age;
        int age2 = o.age;
//        if (age1 == age2){
//            return 0;
//        }else if (age1 > age2){
//            return 1;
//        }else{
//            return -1;
//        }
        //return this.age - o.age;//上面的代码用一行就能实现
        return o.age - this.age;//上面的代码用一行就能实现
    }

    @Override
    public String toString() {
        return "Customer{" +
                "age=" + age +
                '}';
    }
}

在这里插入图片描述

p712 比较规则该怎么编写

package com.bjpowernode.day24.Collection;

import java.util.TreeSet;

public class TreeSetTest05 {
    public static void main(String[] args) {

        Vip v1 = new Vip(12,"zhangsan");
        Vip v2 = new Vip(34,"wangwu");
        Vip v3 = new Vip(12,"maliu");
        Vip v4 = new Vip(23,"huge");

        TreeSet<Vip> vips = new TreeSet<>();

        vips.add(v1);
        vips.add(v2);
        vips.add(v3);
        vips.add(v4);

        //遍历TreeSet
        for(Vip v : vips){
            System.out.println(v);
        }

    }
}
class Vip implements Comparable<Vip>{
    private int age;
    private String name;

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

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

    @Override
    /**
     * compareTo()方法的返回值很重要
     * 返回0表示相同，直接覆盖
     * 返回>0,会继续在右子树上面找
     * 返回<0,会继续在左子树上找
     */
    public int compareTo(Vip o) {
        if (this.age == o.age){
            //年龄相等时，用姓名比较，使用compareTof方法
            return this.name.compareTo(o.name);
        }else{
            return this.age - o.age;
        }
    }
}

p713 自平衡二叉树数据结构【实际上就是数据结构的二叉排序树】

下图中是普通的二叉排序树，和平衡二叉树不是一个东西

p714 实现比较器接口

使用比较器的方式

package com.bjpowernode.day24.Collection;

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

/**
 * TreeSet中元素可排序的第一种方式：类定义时加implements Comparable
 * TreeSet中元素可排序的第二种方式：使用比较器的方式
 */
public class TreeSetTest06 {
    public static void main(String[] args) {

        WuGui wg1 = new WuGui(12);
        WuGui wg2 = new WuGui(45);
        WuGui wg3 = new WuGui(49);
        WuGui wg4 = new WuGui(23);

        //创建TreeSet的时候，需要使用这个比较器
        //TreeSet<WuGui> wuGuis = new TreeSet<>();这样不行，没有使用比较器

        //给构造方法传递一个比较器
        TreeSet<WuGui> wuGuis = new TreeSet<>(new WuguiComparator());

        wuGuis.add(wg1);
        wuGuis.add(wg2);
        wuGuis.add(wg3);
        wuGuis.add(wg4);

        for (WuGui wg:wuGuis){
            System.out.println(wg);
        }


    }
}
class WuGui{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "小乌龟[" +
                "age=" + age +
                ']';
    }
}

//单独在这编写一个比较器
//比较器实现在java.util.Comparator接口（Comparable是java.lang包下的。）

class WuguiComparator implements Comparator<WuGui>{

    @Override
    public int compare(WuGui o1, WuGui o2) {
        //指定比较规则
        return o1.age - o2.age;
    }
}

匿名内部类

package com.bjpowernode.day24.Collection;

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

/**
 * TreeSet中元素可排序的第一种方式：类定义时加implements Comparable
 * TreeSet中元素可排序的第二种方式：使用毕比较器的方式
 */
public class TreeSetTest06 {
    public static void main(String[] args) {

        WuGui wg1 = new WuGui(12);
        WuGui wg2 = new WuGui(45);
        WuGui wg3 = new WuGui(49);
        WuGui wg4 = new WuGui(23);

        //创建TreeSet的时候，需要使用这个比较器
        //TreeSet<WuGui> wuGuis = new TreeSet<>();这样不行，没有使用比较器

        //给构造方法传递一个比较器
//        TreeSet<WuGui> wuGuis = new TreeSet<>(new WuguiComparator());

        //使用匿名内部类方法实现比较(这个类没有名字，直接new接口)
        TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {
            @Override
            public int compare(WuGui o1, WuGui o2) {
                return o1.age - o2.age;
            }
        });

        wuGuis.add(wg1);
        wuGuis.add(wg2);
        wuGuis.add(wg3);
        wuGuis.add(wg4);

        for (WuGui wg:wuGuis){
            System.out.println(wg);
        }


    }
}
class WuGui{
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "小乌龟[" +
                "age=" + age +
                ']';
    }
}

//单独在这编写一个比较器
//比较器实现在java.util.Comparator接口（Comparable是java.lang包下的。）


/**
 * 可以不使用比较器，而是使用匿名内部类
 */
//
//class WuguiComparator implements Comparator<WuGui>{
//
//    @Override
//    public int compare(WuGui o1, WuGui o2) {
//        //指定比较规则
//        return o1.age - o2.age;
//    }
//}

在这里插入图片描述

p715 Collections工具类

package com.bjpowernode.day24.Collection;

import java.util.*;

/**
 * Collection 集合接口
 * Collections 集合工具类，方便集合的操作
 */
public class CollectionsTest {
    public static void main(String[] args) {

        //list不是线程安全的
        List<String> list = new ArrayList<>();

        //变成线程安全的
        Collections.synchronizedList(list);

        //排序
        list.add("abc");
        list.add("abe");
        list.add("aaa");
        list.add("tyu");

        Collections.sort(list);

        //遍历方式1
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//
//        }
        //遍历方式2
        for (String s : list ){
            System.out.println(s);
        }

        //对自定义的类实现排序，需要实现comparable接口
        List<Dog> dogs = new ArrayList<>();

        dogs.add(new Dog(12));
        dogs.add(new Dog(67));
        dogs.add(new Dog(45));
        dogs.add(new Dog(34));

        //对List集合的元素进行排序，需要保证list集合中的元素实现了comparable接口
        Collections.sort(dogs);

        for (Dog d : dogs){
            System.out.println(d);
        }

        //对Set集合进行排序
        Set<String> set = new HashSet<>();

        set.add("abd");
        set.add("acb");
        set.add("sff");
        set.add("edd");

        //Collections.sort(set);//此处的参数必须是list类型
        //将set集合转为list集合，再进行排序
        List<String> list2 = new ArrayList<>(set);//新建一个list，将set作为参数传进去


        //set转为list类型再去排序
        Collections.sort(list2);

        for (String ss : list2){
            System.out.println(ss);
        }

        //Collections.sort(list对象，比较器对象);


    }
}
class Dog implements Comparable<Dog>{
    int age;

    public Dog(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Dog o) {
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "Dog[" +
                "age=" + age +
                ']';
    }
}