java容器大全（java基础篇）

最新推荐文章于 2024-07-19 17:37:28 发布

跳崖寻死的鸟

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量298

点赞数 1

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_45676738/article/details/105468690

版权

笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

java容器介绍

本文将会一一介绍图中的容器

泛型的简单介绍

容器中泛型出现频率有点高，所以先介绍介绍泛型。当参数类型不确定,或者要经常变动时就可以用泛型来解决。直接看代码就可以了解泛型的用法。
注意泛型接口只能给泛型类来实现。泛型对泛型

public class GenericDemo {
    //在类名后面加上<E>代表E是编译时给什么类型就什么类型
    //可以把E看作对像
    static class A<E>{
        private E name;

        public E getName() {
            return name;
        }
        public void setName(E name) {
            this.name = name;
        }
    }
    // 泛型定义在方法上
   public static <E> void demo01(E e){
        
    };
    // 泛型定义在方法上 返回值也是泛型
    public static <E> E demo02(E e){

        return e;
    };
    public static void main(String[] args) {
        //这么new A类中的E就代表是String
        //?问号代表通配符
        A<?> a1 = new A<String>();
        //这么new A类中的E就代表是Integer
        a1= new A<Integer>();

        //如果不用通配符 只能定义两个变量
        A<String> a = new A<String>();
        A<Integer> b = new A<Integer>();

    }
}

Comparable和Comparator

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的。一般用在类去实现其接口，实现compareTo方法。返回值负数：小于，0：等于，正数：大于。
Comparator。是外比较器。一般用于作为参数传达。如sort（，，）。要怎么排序就用到了Comparator接口。要实现compare方法。返回值负数：小于，0：等于，正数：大于。

Collection

从文章开头的图可知Collection接口被List，set，Queue接口给继承了。所以Collection有的方法List和Set也有。先介绍其基本的方法

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        //需要选择一个实现Collection的接口。
        Collection<String> c1 = new ArrayList<>();
        //add();往里面加一个函数
        c1.add("张三");
        c1.add("李四");
        Collection<String> c2 = new ArrayList<>();
        //add();往里面加一个函数
        c2.add("zhangsan");
        c2.add("lisi");
        //获取集合的长度
        int size = c1.size();
        System.out.println(size);//2
        //是否为空
        boolean empty = c1.isEmpty();
        System.out.println(empty);//false
        //查看是否包含了该元素
        boolean bool= c1.contains("张三");
        System.out.println(bool);//true
        //把c2加在c1里
        //c1=c1+c2;
        c1.addAll(c2);
        System.out.println(c1);//[张三, 李四, zhangsan, lisi]
        //清空c1中包含的c2值
        c1.removeAll(c2);
        System.out.println(c1);//[张三, 李四]
        //清空指定的元素
        c1.remove("张三");
        System.out.println(c1);//[李四]
        //清空集合
        c1.clear();
        System.out.println(c1);//[]
    }
}

List

List是有序可重复的容器。

ArrayList

ArrayList是实现List接口的一个实现类。其内部是用数组来实现的。线性表。实现了自动扩充数组的长度。无需定义数组大小。查询效率高，增加删除效率低。这也是线性表的特性。

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

public class Main {
    public static void main(String[] args)  {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("B");
        lsit.add("D");
        //list.remove();根据参数值去删除集合中的元素
        list.remove("D");
        System.out.println(list);//[A, B, C,B]
        //get(0);根据索引来获取值
        String value01 = list.get(0);
        System.out.println(value01);//A
        //从开头开始找和B一样的。返回其索引
        int startIndexb = list.indexOf("B");
        System.out.println(startIndexb);//1
        //从结尾开始找和B一样的。返回其索引
        int endIndexb = list.lastIndexOf("B");
        System.out.println(endIndexb);//3
        //转换为数组
         Object[] objects = list.toArray();

         //和string的subList一样
        List<String> list1 = list.subList(0, 2);
        System.out.println(list1);//[A, B]
        //把索引为一的值修改为F
        list1.set(1,"F");
        System.out.println(list);//[A, F, C, B]

        List<String> list02 = new ArrayList<>();
        list02.add("A");
        list02.add("B");
        list02.add("E");
          //list的值是[A, F, C, B]
        //取交值然后赋值给list
        list.retainAll(list02);
        System.out.println(list);//[A, B]
        //list=[A, B]
        //在一处插入一个C
        list.add(1,"C");
        System.out.println(list);//[A, C, B]
    }
}

LinkedList

LinkedList也是List的实现类。使用方法和ArrayList区别不大。不同的是LinkedList是链表的方式来实现的。查询效率低，增加删除效率高

Vector

Vector和ArrayList去区别是Vector加了同步锁线程安全效率比ArrayList低。

Set

Set接口继承了Collection接口。无序不可重复的集合。

HashSet

HashSet底层是通过hash来存储的。就链表和线性表的结合。同过hashCode去指定数组的位置数组保存的是一条链表。java规定eq为true是hashCode一定相等。当对象重写了eq的方法也一个重写hashCode。像String类一样
用法可以参照Collection

public class Main {
    public static void main(String[] args)  {
        HashSet<String> set = new HashSet<>();
        set.add("a");
        set.add("a");
        //重复插入只能接受一个。set不能重复
        int size = set.size();
        System.out.println(size);//1
    }
}

LinkedHashSet+Comparable

LinkedHashSet和HashSet区别不大。
LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。
LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微逊色于HashSet。

TreeSet

TreeSet对插入的值进行排序

public class Main {

    static class User implements Comparable<User>{
        private Integer id;
        private Integer money;


        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public Integer getMoney() {
            return money;
        }

        public void setMoney(Integer money) {
            this.money = money;
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", money=" + money +
                    '}';
        }
负数：小于，0：等于，正数：大于
        @Override
        public int compareTo(User o) {
            if(this.id>o.id){
                return 1;
            }else if(this.id<o.id){
                return -1;
            }
            return 0;
        }
    }

    public static void main(String[] args)  {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(4);
        set.add(6);
        set.add(5);
        System.out.println(set);//[1, 4, 5, 6]

        //如果是对象，需要实现Comparable<T>接口
        TreeSet<User> userSet = new TreeSet<>();

        User user01 = new User();
        user01.setId(1);
        user01.setMoney(1000);
        User user02 = new User();
        user02.setId(3);
        user02.setMoney(5000);
        User user03 = new User();
        user03.setId(2);
        user03.setMoney(2000);

        userSet.add(user01);
        userSet.add(user02);
        userSet.add(user03);

        System.out.println(userSet);//[User{id=1, money=1000}, User{id=2, money=2000}, User{id=3, money=5000}]
    }
}

Queue

队列，先进先出

LinkedList

LinkedList实现了队列的接口。链表形式，前面已经介绍过

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args)  {
        Queue<String> queue = new LinkedList<>();
        //  offer()方法往队列添加元素如果队列已满直接返回false,队列未满则直接插入并返回true;
        queue.offer("A");
        queue.offer("B");
        //  remove()方法直接删除队头的元素，返回删除的元素:队列没有元素时抛异常
        String a = queue.remove();
        System.out.println(a);//A
        //  poll()方法取出并删除队头的元素,当队列为空,返回null;
        String poll = queue.poll();
        System.out.println(poll);//B
        System.out.println(queue.size());//0
        // peek()方法直接取出队头的元素,并不删除.不存在时返回null
        String peek = queue.peek();
        System.out.println(peek);//null
        int size = queue.size();
        System.out.println(size);//0
    }
}

ArrayQueue

线性表存储队列用法和LinkedList一样

PriorityQueue

PriorityQueue 一个基于优先级的无界优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。该队列不允许使用 null 元素也不允许插入不可比较的对象(没有实现Comparable接口的对象)。

Stack

先进后出

import java.util.Stack;

public class Main {
    public static void main(String[] args)  {
        Stack<String> stack = new Stack();
        stack.push("A");
        stack.push("B");
        stack.push("C");
       //移除栈顶对象，并作为函数的值 返回该对象。为空时会抛异常
        String pop = stack.pop();
        //查看栈顶对象而不移除它。。
        String peek = stack.peek();//为空时会抛异常
        //判断是否为空
        boolean empty = stack.empty();
        System.out.println(empty);
    }
}

Map

按键值对存储数据。key:value。key不可重复。value可重复。Set其实就是Map的key

HashMap

HashMap就是通过传入的键值对，通过hash算法指向一个连续的存储空间（数组存储），将键值对存入数组；对于指向相同的存储空间的hash值，再以链表方式存储；这样hashmap不仅具有了数据查询快速的特性，同时有了链表方便插入、删除的特性；因此hashMap对于数据的存储查询具有非常好的特性；

import java.util.HashMap;
import java.util.Set;

public class Main {
    public static void main(String[] args)  {
        HashMap<String, String> map = new HashMap<>();
        //添加元素
        map.put("一号","小明");
        map.put("二号","小红");
        map.put("三号","小李");
        int size = map.size();
        System.out.println(size);
        //通过key获取value 不存在时返回null
        String name = map.get("一号");
        System.out.println(name);
        //把一号的值替换成小米
        map.replace("一号","小米");
        
        name = map.get("一号");
        System.out.println(name);
        //Key存在时会覆盖
        map.put("一号","大米");
        name = map.get("一号");
        System.out.println(name);
        //获取key的set集合
        Set<String> strings = map.keySet();
        //去掉一号
        map.remove("一号");
    }
}

LinkedHashMap

LinkedHashMap 和HashMap的区别是LinkedHashMap 是有序的（按照插入的顺序）

LinkedHashMap是有序的原因：LinkedHashMap 继承自HashMap 并且实现了Map接口，是HashMap的子类额外增加了before after 用于指向前一个Entry 后一个Entry。也就是说，元素之间维持着一条总的链表数据结构。正式因为这个链表才保证了LinkedHashMap的有序性。

TreeMap

可以参照TreeSet，一样的。这里不重复介绍

容器的遍历Iterator+listIterator

Iterator和listIterator的区别。listIterator是List特有的

ListIterator有add()方法，可以向List中添加对象，而Iterator不能
ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。previous只是倒着走（i–，i开始是0的）开头是指向第一个元素
ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。

遍历List方法一Iterator

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

public class Main {
    public static void main(String[] args)  {
        List<String> list = new ArrayList<>();
         list.add("a");
         list.add("b");
         list.add("c");
         list.add("d");
         list.add("e");
        Iterator<String> iterator = list.iterator();
        ListIterator<String> listIterator = list.listIterator();
        System.out.println(list.size());//5
        //iterator.hasNext()如果遍历结束会返回false
        while (iterator.hasNext()){
            //获取遍历中的值。会自动往后走。类似i++。
            String next = iterator.next();
            if(next.equals("d")||next.equals("a")){
               // System.out.println(next);
                //不要用list.remove。会报错
                iterator.remove();
            }
        }
        int size = list.size();
        System.out.println(size);//3
    }
}

遍历List方法二listIterator

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Main {
    public static void main(String[] args)  {
        List<String> list = new ArrayList<>();
         list.add("a");
         list.add("b");
         list.add("c");
         list.add("d");
         list.add("e");
        ListIterator<String> listIterator = list.listIterator();
        //注意如果一开始就hasPrevious();会是false。因为都是从开头开始的
        //hasPrevious()是代表向后走。开始都是指向0了
        //先走到结尾
        while (listIterator.hasNext()) {
            listIterator.next();
        }
        //倒叙输出
        while (listIterator.hasPrevious()){
            String previous = listIterator.previous();
            int index = listIterator.previousIndex();
            System.out.println(index+":"+previous);
        }
    }
}

遍历Set

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

public class Main {
    public static void main(String[] args)  {
        Set<String> set = new HashSet<String>();
         set.add("a");
         set.add("b");
         set.add("c");
         set.add("d");
         set.add("e");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

遍历Map方式一

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

public class Main {
    public static void main(String[] args)  {
        Map<Integer,String> map1 = new HashMap<>();
        map1.put(100, "aa");
        map1.put(200, "bb");
        map1.put(300, "cc");
         //先获取set集合
        Set<Map.Entry<Integer,String>>  ss =  map1.entrySet();
        //通过set集合遍历
        Iterator<Entry<Integer, String>> iterator = ss.iterator();
          while (iterator.hasNext()){
              Entry<Integer, String> next = iterator.next();
              //获取遍历的key
              Integer key = next.getKey();
              //获取value
              String value = next.getValue();
              System.out.println(key+":"+value);
          }

    }
}

遍历Map方式二

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

public class Main {
    public static void main(String[] args)  {
        Map<Integer,String> map1 = new HashMap<>();
        map1.put(100, "aa");
        map1.put(200, "bb");
        map1.put(300, "cc");
         //先获取set集合.map的可以做元素
        Set<Integer> setKey = map1.keySet();
        //通过set集合遍历
        Iterator<Integer> iterator = setKey.iterator();
          while (iterator.hasNext()){
              Integer key = iterator.next();
              //获取value.通过key
              String value = map1.get(key);
              System.out.println(key+":"+value);
          }
    }
}

Collections是工具类不要Collection混淆

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

public class Main {
    public static void main(String[] args)  {
        List<String> list  = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add("list:"+i);
        }

        System.out.println(list);

        Collections.shuffle(list);	//随机排列list中的元素
        System.out.println(list);

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

        Collections.sort(list);		//按照递增的方式排序。自定义的类使用：Comparable接口。
        System.out.println(list);

        System.out.println(Collections.binarySearch(list, "list:1")); 	//二分法查找，或者：折半查找

        String max = Collections.max(list);
        System.out.println(max);
    }
}

会一直更新学习笔记。喜欢java的小伙伴可以关注我。

跳崖寻死的鸟

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
java容器大全（java基础篇）

java容器介绍本文目录java容器介绍泛型的简单介绍Comparable和ComparatorCollectionListArrayListLinkedListVectorSetHashSetLinkedHashSet+ComparableTreeSetQueueLinkedListArrayQueuePriorityQueueStackMapHashMapTreeMap容器的遍历Iterat...
复制链接

扫一扫