Java从入门到放弃12

HashSet

采用hash表实现；

元素不重复，无序的，允许存null；

不能按下标读取元素，只能遍历。

HashSet的常用方法：

package com.hqyj;

import java.util.HashSet;

public class HashSetDemo {
    public static void main(String[] args) {
        //创建HashSet，默认长度是16，加载因子是0.75
        HashSet set = new HashSet<>();
        //添加元素
        set.add("Java");
        set.add("Html");
        set.add("SOL");
        set.add("Java");//重复的内容，HashSet里面只会存储第一个出现的
        System.out.println(set.size());
        System.out.println(set);

        //遍历set的元素
        System.out.println("========foreach遍历========");
        for (String str : set) {
            System.out.println(str);
        }

        //查找是否包含某个对象（对象要重写hashCode的方法）
        System.out.println(set.contains("Java"));

        //删除set里的集合
        set.remove("Java");

        //清空整个set
        set.clear();

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


    }
}

练习：

给出一个数组，去掉数组中重复的元素，返回一个新的数组。{1, 2, 3, 4, 2, 5, 6, 6, 7, 5, 8, 6}

package com.hqyj;

import java.util.Arrays;
import java.util.HashSet;

public class SetExam {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 2, 5, 6, 6, 7, 5, 8, 6};
        HashSet set = new HashSet<>();
        for (int i : arr1){
            set.add(i);
        }
        int[] arr2 = new int[set.size()];
        int i = 0;
        for (int j : set) {
            arr2[i] = j;
            i++;
        }
        System.out.println(Arrays.toString(arr2));
    }
}

TreeSet

二叉树：每个节点下面最多只能有两个分支；
满二叉树：二叉树的根节点和子节点都有两个分支；
完全二叉树：最底层的叶子节点不完全，但是从不全的那个子节点开始，左边的子节点的叶子节点必须是完全的，右边的都是叶子节点；

二叉查找数：每个节点左节点比父节点小，右节点比父节点大。
平衡二叉树：左右子树高度查不能大于1；

红黑树：一种自平衡的二叉查找树。

特征：

节点只有红色和黑色；
根节点是黑色；
叶子节点为黑色，叶子节点存NULL；
一个节点为红色，则它的两个子节点必须为黑色（不存在两个连续的红色节点）；
每个节点到叶子节点的所有路径，都包含相同数目的黑色节点。

TreeSet的特征

TreeSet是通过红黑树的数据结构来实现的；
不能添加null，也不能添加重复的元素；
添加的元素会被排序，遍历出来是按顺序排列的；
TreeSet的元素必须要实现Comparable（可比较的）接口，如果没有实现，运行时就会抛出类型转换错误异常（ClassCastException））

常用的方法：

package com.hqyj;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet set = new TreeSet<>();
        set.add(20);
        set.add(25);
        set.add(8);
        set.add(16);

        //返回元素的个数
        System.out.println("元素的个数：" + set.size());

        //返回排序后的第一个元素
        System.out.println("first" + set.first());

        //返回排序后的最后一个元素
        System.out.println("last" + set.last());

        //返回比指定元素大的最小的元素
        System.out.println("ceiling" + set.ceiling(18));//20

        //返回比指定元素小的最大的元素
        System.out.println("floor" + set.floor(18));//16

        //遍历是按元素从大到小的顺序排序的
        for (Integer i : set) {
            System.out.println(i);
        }

        //删除指定的对象
        set.remove(20);

        //清空所有的元素
        set.clear();

        //判断是否是空
        System.out.println("判断是否是空：" + set.isEmpty());
    }
}

TreeSet存放自定义的类型

定义Egg类型

必须实现Comparable接口；

实现compareTo方法：

跟它比较的另一个对象
1 当前对象大于参数对象，返回1 （升序排列，如果要降序就返回-1）
-1 当前对象比参数对象小，返回-1
0 当前对象跟参数对象相等，返回0

package com.hqyj;

//类要放进TreeSet（排序），必须要实现Comparable接口，泛型跟当前这个类一样
public class Egg implements Comparable{
    private float weight;

    public Egg(float weight) {
        this.weight = weight;
    }

    public float getWeight() {
        return weight;
    }

    public void setWeight(float weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Egg{" +
                "weight=" + weight +
                '}';
    }

    

    @Override
    public int compareTo(Egg o) {
        if (this.weight > o.weight){
            return 1;
        }else if (this.weight < o.weight){
            return -1;
        }else{
            return 0;
        }
    }
}

测试代码

TreeSet里面的对象按升序排列

*
TreeSet存放自定义的对象
 */
    
TreeSet eggs = new TreeSet<>();
eggs.add(new Egg(50.0F));
eggs.add(new Egg(45.5F));
eggs.add(new Egg(78.5F));
eggs.add(new Egg(41));

for (Egg egg : eggs) {
    System.out.println(egg);
}

练习：

创建运动员（Sportsman）对象，有个姓名的属性和成绩（score）的属性；按照得分从高到底排序，打印运动员的姓名和成绩。

创建一个Sportsman类

package com.hqyj;

public class Sportsman implements Comparable{
    private String name;
    private double score;

    public Sportsman(String name, double score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Sportsman{" +
                "name='" + name + ''' +
                ", score=" + score +
                '}';
    }


    @Override
    public int compareTo(Sportsman o) {
        if (this.score > o.score){
            return -1;
        }else if (this.score < o.score){
            return 1;
        }else{
            return 0;
        }
    }
}

测试代码：

package com.hqyj;

import java.util.TreeSet;

public class SportsmanTest {
    public static void main(String[] args) {
        TreeSet sportsmens =new TreeSet<>();
        sportsmens.add(new Sportsman("张三", 82.5));
        sportsmens.add(new Sportsman("李四", 79.3));
        sportsmens.add(new Sportsman("王二", 88.6));
        sportsmens.add(new Sportsman("刘大", 91.6));
        sportsmens.add(new Sportsman("孙武", 86.3));

        for (Sportsman sportsman : sportsmens) {
            System.out.println(sportsman);
        }
    }
}

Collection 集合用迭代器遍历

List迭代遍历

package com.hqyj;

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

public class IteratorDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(1);
        list.add(6);
        list.add(12);
        list.add(8);

        //返回一个迭代器，迭代器是一个接口，迭代器里面存有数据
        Iterator iterator = list.iterator();
        //hasNext()方法判断里面是否还有数据
        while (iterator.hasNext()){
            //next()从迭代器中取出一个数据，取一个少一个
            Integer integer = iterator.next();
            System.out.println(integer);
        }
    }
}

Set迭代遍历

package com.hqyj;

import java.util.*;

public class IteratorDemo {
    public static void main(String[] args) {
        
        Set set = new HashSet<>();
        set.add(3);
        set.add(9);
        set.add(7);
        set.add(5);
        
        Iterator iterator1 = set.iterator();
        while (iterator1.hasNext()){
            Integer integer = iterator1.next();
            System.out.println(integer);
        }
    }
}

Collections集合工具类

面试题：Collection跟Collections的区别

Collection是一个接口，它是List和Set的父接口；

Collections是一个处理集合类型数据的工具类。

Collections的基本用法：

package com.hqyj;

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

public class CollectionsDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(67);
        list.add(23);
        list.add(18);
        list.add(99);

        //随机打乱list的顺序
        Collections.shuffle(list);
        System.out.println("=======随机打乱list的顺序=======");
        for (Integer i : list) {
            System.out.println(i);
        }

        //使list逆序排列
        Collections.reverse(list);
        System.out.println("=======逆序排列=======");
        for (Integer i : list) {
            System.out.println(i);
        }

        //使list排序，如果要排序，list里面的类型必须要实现Comparable接口（类似TreeSet里面的对象）
        Collections.sort(list);
        System.out.println("=======排序=======");
        for (Integer i : list) {
            System.out.println(i);
        }

        //交换两个下标的元素
        Collections.swap(list, 0, 3);
        System.out.println("=======交换两个下标的元素=======");
        for (Integer i : list) {
            System.out.println(i);
        }

        //返回集合中最大的元素
        Integer max = Collections.max(list);
        System.out.println("max" + max);

        //返回集合中最小的元素
        Integer min = Collections.min(list);
        System.out.println("min" + min);

    }
}

Map

保存键值对数据（key-value);
key的值不能重复，value的值可以重复；
key和value都可以为null

HashMap

通过数组+链表+红黑树的数据结构来实现：

先根据hash code保存到数组中；
如果出现hash碰撞，转用链表；
如果链表长度超过8，改用红黑树

HashMap基本方法的使用：

package com.hqyj;

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

public class HashMapDemo {
    public static void main(String[] args) {
        //默认长度为16，加载因子0.75
        HashMap map = new HashMap<>();
        //王map插入数据，第一个参数key，第二个参数value
        map.put("yyds", "永远的神");
        map.put("emo", "抑郁了");
        map.put("u1s1", "有一说一");

        //根据key查询对象value
        System.out.println(map.get("yyds"));

        //判断map中是否存在某个key
        System.out.println("containsKey" + " " + map.containsKey("yyds"));
        //判断map中是否存在某个value
        System.out.println("containsValue" + " " + map.containsValue("永远的神"));

        //返回map的个数
        System.out.println("size" + " " + map.size());

        //遍历map
        System.out.println("======遍历value=======");
        Collection values = map.values();//以Collection数据类型返回所有的value
        for (String str : values) {
            System.out.println(str);
        }

        System.out.println("======遍历key=======");
        Set strings = map.keySet();//以set数据类型返回所有的key
        for (String str : strings) {
            System.out.println(str);
        }

        System.out.println("======遍历entry=======");
        Set> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println(entry.getKey() + "," + entry.getValue());
        }

        //删除key指定的元素
        map.remove("key");

        //清除所以元素
        map.clear();

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

Java从入门到放弃12

Java相关栏目本月热门文章