java学习第12天

java学习第12天

hashset

采用hash表实现

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

HashSet的常用方法

//创建HashSet，默认长度是16，加载因子为0.75。
        HashSet<Object> set = new HashSet<>();
        //添加元素
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add(6);
        set.add(6);//重复的内容在Set里面只有一个
        System.out.println(set);

		//返回集合中元素的个数
		System.out.println(set.size());

        //遍历元素
        for (Object o :set) {
            System.out.println(o);
        }
        //查找是否包含某个对象（对象要重写HashCode和equals）
        System.out.println(set.contains("张三"));

        //删除set的元素
        set.remove("王五");
        System.out.println(set);

        //清空set集合
        set.clear();
        System.out.println(set);

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

**练习：**给出一个数组，请把数组中重复的元素去掉，返回一个新的数组

{1,30,25,40,18,30,22,40}

        Integer[] arr = {1,30,25,40,18,30,22,40};
        Set<Integer> staffsSet1 = new HashSet<>(Arrays.asList(arr));
        System.out.println(staffsSet1);
        Object[] intarr = staffsSet1.toArray();
        System.out.println(Arrays.toString(intarr));

TreeSet

• 二叉树

  每一个节点下面最多之后两个分支

• 满二叉树

  除了叶子节点之外，每个分支都有两个节点

• 完全二叉树

  叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。需要注意的是，满二叉树肯定是完全二叉树，而完全二叉树不一定是满二叉树。

• 二叉查找树（二叉搜索树）

  若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

• 平衡二叉树

  它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。

• 红黑树

  它是一种自平衡的二叉查找树

  特征：

  1. 节点只有红色和黑色
  2. 根节点是黑色
  3. 叶子结点为黑色，并且叶子结点不放数据（null）
  4. 一个节点为红色，则它的两个子节点必须为黑色。（从根节点到叶子结点的所有路径不可能存在两个连续的红色节点）
  5. 每一个节点到叶子节点的所有路径，都包含相同数目的黑色节点
     

TreeSet的特征：

• TreeSet采用红黑树的数据结构实现的。

• 不能添加NULL

• 也不能添加重复的元素，

• 添加的元素会被排序，遍历出来是按顺序排列的。

• TreeSet的元素必须要实现Comparable （如果没有实现Comparable接口，运行时抛出类型转换错误异常。

常用的方法:

TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(20);
        treeSet.add(25);
        treeSet.add(8);
        treeSet.add(30);
        treeSet.add(20);

        //是按照元素排序显示的
        System.out.println(treeSet);
        //返回元素个数
        System.out.println("元素个数是："+treeSet.size());

        System.out.println("第一个元素"+treeSet.first());
        System.out.println("最后一个元素"+treeSet.last());

        //返回比指定的元素大的最小元素
        System.out.println("大于18最小的数"+treeSet.ceiling(18));
        //返回比指定的元素小的最大元素
        System.out.println("小于26的最大的数"+treeSet.lower(26));

        //删除指定的对象
        treeSet.remove(20);
        System.out.println(treeSet);
        //清空集合中的元素
        treeSet.clear();
        System.out.println(treeSet);
        //判断是否是空
        System.out.println("是否是空："+treeSet.isEmpty());

TreeSet存放自定义的类型

• 定义Egg类

  必须实现接口Comparable

  实现comparableTo() 方法，当前对象比参数大，返回-1（降序），小于返回1，等于返回0

  public class Egg implements Comparable<Egg>{
  private float weight;
  
  //ToString方法
  @Override
      public String toString() {
          return "Egg:"+ 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<Egg> eggs = new TreeSet<>();
          eggs.add(new Egg(50));
          eggs.add(new Egg(45.6F));
          eggs.add(new Egg(76.5F));
          eggs.add(new Egg(38.6F));
          System.out.println(eggs);
  

  截图：

练习：

创建一个运动员对象（sportsman），有一个成绩（score）和姓名的属性，按照得分的情况从高到低排序，打印出运动员的姓名和成绩 。

• Sportsman

  public class Sportsman implements Comparable<Sportsman>{
      private String name;
      private Double score;
  
      public Sportsman() {
      }
  
      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 1;//重复时不覆盖
      }
  }
  
  

• 测试代码

  import java.util.Scanner;
  import java.util.TreeSet;
  
  public class SportsmanTest {
      public static void main(String[] args) {
          Sportsman sportsman = new Sportsman();
          Scanner scanner = new Scanner(System.in);
          TreeSet<Sportsman> set = new TreeSet<>();
          while (true) {
              System.out.println("请输入姓名：");
              sportsman.setName(scanner.next());
              try {
              System.out.println("请输入成绩：");
              sportsman.setScore(scanner.nextDouble());
              set.add(sportsman);
              sportsman = new Sportsman();
                  System.out.println("是否继续添加(0退出，1继续");
                  int i = scanner.nextInt();
                  if(i == 0){
                      break;
                  }
              } catch (Exception e) {
                  e.printStackTrace();
                  System.out.println("请正确输入命令");
              }
          }
          for (Sportsman s : set) {
              System.out.println(s);
          }
  
      }
  }
  
  

迭代器

• list类型迭代遍历

   public static void main(String[] args) {
          List<Integer> list = new ArrayList<>();
          list.add(1);
          list.add(5);
          list.add(6);
          list.add(3);
          list.add(9);
  
          //返回迭代器
          Iterator<Integer> iterator = list.iterator();
          //hashNext()方法判断里面还有没有数据
          while (iterator.hasNext()){
              //next()方法从迭代去取出一个数据，取一个少一个
              Integer i = iterator.next();
              System.out.println(i);
          }
  
      }
  

• set类型迭代遍历

  public static void main(String[] args) {
          Set<Integer> set = new HashSet<>();
          set.add(1);
          set.add(5);
          set.add(6);
          set.add(3);
          set.add(9);
  
          //返回迭代器
          Iterator<Integer> iterator = set.iterator();
          //hashNext()方法判断里面还有没有数据
          while (iterator.hasNext()){
              //next()方法从迭代去取出一个数据，取一个少一个
              Integer i = iterator.next();
              System.out.println(i);
          }
  
      }
  

Collections集合工具类

• 面试题：Collection与Collections的取悦

  Collection是一个接口，它是list和set的父接口

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

Collections的用法

List<Integer> list = new ArrayList<>();
        list.add(6);
        list.add(69);
        list.add(78);
        list.add(35);
        list.add(65);
        list.add(15);

        //打乱list集合的顺序
        Collections.shuffle(list);
        System.out.println(list);

        //reverse逆序排列
        Collections.reverse(list);
        System.out.println(list);

        System.out.println("========排序=======");
        //让list排序，如果要排序，list里面的类型必须要实现Comparable接口（类似TreeSet接口）
        Collections.sort(list);
        System.out.println(list);

        //交换两个下标的元素
        Collections.swap(list,3,0);
        System.out.println(list);

        //返回集合中最大的元素
        System.out.println(Collections.max(list));
        //返回集合中最小的元素
        System.out.println(Collections.min(list));

Map集合

• 保存键值对数据（key - value）

  如：yyds - 永远滴神

• key不能重复，value可以重复

• key和value 都可以为null

HashMap

采用数组+ 链表+ 红黑树的数据结构来实现的

先根据hasd code 保存到数组中

如果出现了哈希碰撞，用链表

链表长度超过8时，改用红黑树存。

基本方法的使用：

 //默认长度16，加载因子0.75
        Map<Integer,String> map = new HashMap<>();
        //往map插入数据，第一个参数是key，第二个参数是value
        map.put(1905410001,"张三");
        map.put(1905410002,"李四");
        map.put(1905410003,"王五");
        map.put(1905410004,"彭于晏");
        map.put(1905410001,"张三");
        System.out.println(map);
        //根据key查询对象value
        System.out.println(map.get(1905410001));
        //判断是否存在某个key
        System.out.println("是否存在key："+map.containsKey(1905410004));
        //判断是否存在某个value
        System.out.println("是否有彭于晏："+map.containsValue("彭于晏"));
        //删除key为指定值的元素
        System.out.println(map.remove(1905410003));
        System.out.println(map);

        //返回map集合中元素的个数
        System.out.println("size:"+ map.size());

        //遍历map
        System.out.println("========遍历======");
        //map.values()返回所有的value，组成Collection的数组
        Collection<String> values = map.values();
        System.out.println(values);
        //map.values()返回所有的key，组成Set的数组（key）
        Set<Integer> integers = map.keySet();
        System.out.println(integers);
        System.out.println("========遍历======");
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        System.out.println(entries);
        for (Map.Entry<Integer, String> m : entries) {
            System.out.println(m);
            System.out.println(m.getKey()+","+m.getValue());
        }

        //清除所有元素
        map.clear();
        System.out.println(map);
        //判断map是否为空
        System.out.println("是否为空："+map.isEmpty());
    }
}