首页 > 其他 > 详细

集合整理

时间:2021-04-06 21:00:03      阅读:38      评论:0      收藏:0      [点我收藏+]

Collection单列集合

List :

1.有序集合,这里的有序指的是存取顺序用户可以精确控制列表中每个元素的插入位置

2.用户可以通过整数索引访问元素,并搜索列表中的元素与Set集合不同3.列表通常允许重复的元素

ArrayList:

底层是数组:查找快 增删慢

linkedList:

底层是链表:查找慢,增删快

 

list集合的遍历方式

list集合有索引,可以使用普通for 增强for 迭代器进行遍历

 

迭代器,集合专用的遍历方式,就是一个对象,Iterator 三个方法: <1>Iterator<E>Iterator 获取迭代器对象 <2>hasNext(); 判断当前元素是否有元素可以被取出 <3>next()获取当前位置的元素,将迭代器对象移向下一个索引位置。

  while(it.hasNext()){
           System.out.println(it.next());
      }

 

set

1.不可以存储重复元素

2.存取顺序不一致

3.没有索引(不能使用普通for循环遍历,不能通过索引删除修改元素)

TreeSet:

1.不可以存储重复元素

2.存取顺序不一致

3.可以将元素按照规则进行排序(自然排序,比较器排序)

4.底层是一个红黑树

 

自然排序Comparable实现步骤

1.使用空参构造一个TreeSet,使用TreeSet存储一个引用数据类型

2.在类中实现Comparable接口,重写compareTo方法

3.重写方法时注意主要和次要条件。

案例:要求:按照年龄从小到大排序,如果年龄相同,将按姓名的首字母来进行排序
package com.itheima.mytreeset;
?
public class Student implements Comparable<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 int compareTo(Student o) {
       //按照对象的年龄进行排序
       //主要判断条件
       //this 当前进来的对象 o原来留下的对象 正数留下的是小的 负数留下的是大的
       int result = this.age - o.age;
       //次要判断条件
       result = result == 0 ? this.name.compareTo(o.getName()) : result;
       return result;
  }
}
比较器排序Comparator

1.用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序的

2.让集合的构造方法接受Comparator的实现类对象,匿名内部类 重写compare(o1,o2)方法

3.重写方法时注意主要和次要条件。

package com.itheima.mytreeset;
?
import java.util.Comparator;
import java.util.TreeSet;
?
public class MyTreeSet4 {
   public static void main(String[] args) {
       TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
           @Override
           public int compare(Teacher o1, Teacher o2) {
               //o1表示现在要存入的那个元素
               //o2表示已经存入到集合中的元素
?
               //主要条件
               int result = o1.getAge() - o2.getAge();
               //次要条件
               result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
               return result;
          }
      });
?
       Teacher t1 = new Teacher("zhangsan",23);
       Teacher t2 = new Teacher("lisi",22);
       Teacher t3 = new Teacher("wangwu",24);
       Teacher t4 = new Teacher("zhaoliu",24);
?
       ts.add(t1);
       ts.add(t2);
       ts.add(t3);
       ts.add(t4);
?
       System.out.println(ts);
  }
}
自然排序和比较器排序的比较

相同点:接口不同,默认使用的是自然排序 在权限不够时(string,包装类)使用比较器排序

不同点:比较规则一样

 

基本数据结构:

1.二叉树

2.二叉查找树:大的放右边 小的放左边

3.平衡二叉树 :左右高度不超过1

 

HashSet:

1.存取无序

2.不可以存储重复元素

3.没有索引,不能使用普通for循环遍历(get方法)

4.底层数据结构是哈希表(数组+链表+红黑树)

总结
HashSet的底层实现跟HashMap一样 只是value值为空 hashcode()方法默认比较的是引用数据类型的地址值,需要重写hashcode和
equals方法比较的是属性值;

Map双列集合

  1. 键不能重复,值可以重复

  2. 键与值之间是一一对应的关系

  3. (键+值)这个整体我们称之为"键值对"或"键值对对象",在Java中又叫"Entry对象"

    map的遍历方式:
     public static void main(String[] args) {
           //创建集合并添加元素
           Map<String, String> map = new HashMap<>();
           map.put("1号丈夫", "1号妻子");
           map.put("2号丈夫", "2号妻子");
           map.put("3号丈夫", "3号妻子");
           map.put("4号丈夫", "4号妻子");
           map.put("5号丈夫", "5号妻子");
             //1.先拿键 通过键寻找值
    //       Set<String> keySet = map.keySet();
    //       for (String s : keySet) {
    //           String value = map.get(s);
    //           System.out.println(s + value);
    //       }
           //2.直接拿键值对 通过键值对获取key value值
    //       Set<Map.Entry<String, String>> entries = map.entrySet();
    //       for (Map.Entry<String, String> entry : entries) {
    //           String key = entry.getKey();
    //           String value = entry.getValue();
    //           System.out.println(key + value);
    //       }
    ?
          3. map.forEach((String key,String value)->{
               System.out.println(key+"--"+value);
          });
    ?
      }

     

HashMap:

1.依赖hashCode方法和equals方法保证键的唯一

2.如果键要存储自定义对象,需要重写hashCode和equals方法

3.HashMap底层是哈希表结构

TreeMap:

1.依赖自然排序或者比较器排序,对键进行排序

2.如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

3.TreeMap底层是红黑树结构

 

Tree和Hash 保证存取元素不重复原理不同:

Tree:自然排序或者比较器排序返回值等于0

Hash:重写hashCode和equals方法

 

集合整理

原文:https://www.cnblogs.com/zhangmeng0726/p/14623295.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!