集合框架

数据结构概述

什么是数据结构?!

就是对不同类型的数据进行存储,组织数据的方式

数据结构就是用来模拟数据操作的,其实就是对数据的增删改查操作.

增:就是把某个数据存到某个容器中
删:就是把某个数据从容器中删除
改:把容器中的某个数据进行替换
查:把容器中的某个数据查询出来

之所以会有不同的数据结构,是因为底层实现的算法不同,执行某一操作的效率高低的分别.

常见的数据结构有

数组（Array）掌握
链表（Linked List）了解
哈希表（Hash）了解
栈（Stack）了解
队列（Queue）了解
树（Tree）了解
图（Graph）
堆

下面进入正题! ! ! ! !

集合框架体系

集合是Java中提供的一种容器，可以用来存储多个数据，根据不同存储方式形成的体系结构，就叫做集合框架体系

那既然数组可以储存多个数据,为什么还要集合呢?

数组是不可变长度的,集合的长度可变
使用java封装的出一个个容器,开发者只要直接调用就好了

容器的种类:

List(列表):允许添加元素顺序,允许元素重复

Set(集合):不添加元素顺序,不允许元素重复

Map(映射):容器中每个元素都包含一个key和value,key是不允许重复的,而value允许重复,严格来说map不是容器,而是List和Set的映射

注意:List和Set接口继承自Collenction,而map不继承Collection

List接口

接口的实现类有ArraysList(重点),LinkList,Stack,Vector

常用方法

public class ArrayListDemo{
    public static void main(String[] args) {
        List list=new ArrayList();
        //添加操作,add()将元素添加到列表的末尾 
        list.add(1);
        list.add(12);
        list.add("a");
        list.add('C');
        list.add("E");
        System.out.println(list);
        list.add(1,"hahahaha");//在列表的指定位置插入指定的元素
         System.out.println(list);
        
        List list1=new ArrayList();
        list1.add(list);//把c列表中的所有元素添加到当前列表中
        System.out.println(list1);
        
        //删除操作
        System.out.println(list.remove(1));//从列表中删除指定索引位置的元素,并返回被删除的元素
        System.out.println(list1.removeAll(list));//从此列表中移除c列表中的所有元素 
        
        //修改操作
         System.out.println(list.set(1,"aaa"));//修改列表中指定索引位置的元素，返回被替换的旧元素
        
    }
}

Set接口

常用实现类有

HashSet类：底层采用哈希表实现，开发中使用对多的实现类，重点。
TreeSet类：底层采用红黑树实现，可以对集合中元素排序，使用不多。

HashSet常用方法

public class ArrayListDemo2 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //添加操作：向列表中添加4个元素
        set.add("Will");
        set.add("wolf");
        set.add("code");
        set.add("Lucy");
        //查询操作:
        System.out.println("集合中所有元素：" + set);//[code, wolf, Will, Lucy]
        System.out.println("元素数量：" + set.size());//4
        System.out.println("是否存在某个元素：" + set.contains("code"));//true
        System.out.println("是否存在某个元素：" + set.contains("code2"));//false
        //删除操作：删除code元素
        set.remove("code");
        System.out.println("删除后：" + set);//[wolf, Will, Lucy]
        //使用for-each遍历
        for (String ele : set) {
            System.out.println(ele);
        }
        //使用迭代器遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            Object ele = it.next();
            System.out.println(ele);
        }
    }
}

Set集合不允许元素重复,所以当储存的是对象时,需要在类中重写equals和hasCode方法

public class User{
    private String name;
    private Integer age;
    
    public User(){}
    
    public User(String name,Integer age){
        this.name=name;
        this.age=age;
    }
    
    public boolean equals(Object o){
        if(this==0){
            return false;
        }
        if(o==null||getClass()!=o.getClass()){//getClass是java文件的.class文件
            return false;
        }
        User u=(User)o;
        if(name.equals(u.name)&&age.equals(u.age)){
            return true;
        }
        return false;
    }
    
    public int hashCode(Object a[]){
        if(a==null)
            return 0;
        int result=1;
        for(Object ele: a){
            result=31*result+(ele==null?0:ele.hashCode());
        }
        return result;
    }
}

理解即可,这个后期可直接生成

TreeSet类底层使用的红黑树,会对储存元素默认使用自然排序

public class TreeSetDemo{
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("wolf");
        set.add("will");
        set.add("sfef");
        set.add("allen");
        System.out.println(set);//[allen, sfef, will, wolf]按照码表计算大小
    }
}

同样,TreeSet在使用类作为储存对象时,排序会缺省

这是就要求元素对象必须实现Comparable接口,调用comparaTo方法比较元素的大小关系

比较规则，拿当前元素和另一个元素做比较：

this > o：返回正整数 1 ，优先级较高
this < o：返回负整数 -1 ，优先级较低
this == o：返回 0 ，此时认为两个对象为同一个对象。

Public class User implements Comparable<User>{
    private String name;
    private Integer age;
    
      public User(){}
    
    public User(String name,Integer age){
        this.name=name;
        this.age=age;
    }
    
    public int CompareTo(User o){
        if(this.name<o.name){
            return -1;
        }elseif(this.name>o.name){
            return 1;
        }
        return 0;
    }
}

public class ComparableDemo{
    public static void main(String[] args) {
        Set<User> set = new TreeSet<>();
        set.add(new User("stef", 28));
        set.add(new User("will", 17));
        set.add(new User("allen", 15));
        set.add(new User("Lucy", 22));
        System.out.println(set);
    }
}

小结：HashSet做等值查询效率高，TreeSet做范围查询效率高，在开发中一般使用HashSet就可以了

Map接口

常用方法

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
//        添加操作
//        put(Object key,Object value)：存储一个键值对到Map中
        map.put("138","宋江");
        map.put("140","刘备");
        map.put("120","司马懿");
        map.put("150","曹操");
        System.out.println(map);
       
                HashMap<Object, Object> m = new HashMap<>();
        m.putAll(map);//把m中的所有键值对添加到当前Map中
        System.out.println(m);
//        删除操作
//                 Object remove(Object key)：从Map中删除指定key的键值对，并返回被删除key对应的value
        System.out.println(map.remove("138"));
      /*  修改操作
                - 无专门的方法，可以调用put方法，存储相同key，不同value的键值对，可以覆盖原来的。*/
        map.put("140","老朱");
        System.out.println(map);

//        查询操作
        System.out.println(map.size());//返回当前Map中键值对个数
//        isEmpty()：判断当前Map中键值对个数是否为0.
        System.out.println(map.isEmpty());
//         get(Object key)：返回Map中指定key对应的value值，如果不存在该key，返回null
        System.out.println(map.get("140"));
        System.out.println(map.get("138"));
//        containsKey(Object key):判断Map中是否包含指定key
        System.out.println(map.containsKey("140"));
//        containsValue(Object value):判断Map中是否包含指定value
        System.out.println(map.containsValue("刘备"));
//         keySet()：返回Map中所有key所组成的Set集合
        System.out.println(map.keySet());
//        values()：返回Map中所有value所组成的Collection集合
        System.out.println(map.values());
//        entrySet()：返回Map中所有键值对所组成的Set集合
        System.out.println(map.entrySet());
    }
}

List、Set、Map选用

一般的在存储元素时候，是否需要给元素起一个名字：

需要：此时使用Map。
不需：存储的元素使用需要保证先后添加的顺序

需要：此时使用List
不需：此时使用Set（如果需要保证集合元素不重复，也选用Set）

补充(泛型)

类型参数,主要用于某个类或接口数据类型不确定时,可以使用一个标识符代替未知的数据类型,

然后在使用该类或方法时在指定数据类型

泛型可用到的接口、类、方法中，将数据类型作为参数传递，其实更像是一个数据类型模板。

T 表示类型 type

K 表示 key

E 表示元素 element

V 表示值 value

public class Point<T> {//使用泛型需要写在类名上<T,V,K.....>内,可以有多个
    private T x;
    private T y;

    public Point() {
    }

    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }


    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

public class PointDemo{
      public static void main(String[] args) {
          Point<String> p=new Poing<>();
          p.setX("aaa");    
          p.setY("aa");
          System.out.println(p);
      }
}

posted @ 2020-09-01 20:02 默道阅读(293) 评论(0) 收藏举报

刷新页面返回顶部

默道