java容器

最新推荐文章于 2021-03-26 07:59:06 发布

谢谢我不玩

最新推荐文章于 2021-03-26 07:59:06 发布

阅读量126

点赞数

分类专栏： javaEE 文章标签： java 容器 hashmap

本文链接：https://blog.csdn.net/weixin_41623694/article/details/113929167

版权

javaEE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

java容器的类型

java容器的类型

在这里插入图片描述
如上图所示Java的容器主要继承Collection接口和Map接口：

Set和List的区别

Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

Collection接口

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，
这些方法可用于操作所有的单列集合。方法如下︰

public boolean add(E e):把给定的对象添加到当前集合中。
public void clear():清空集合中所有的元素。
public boolean remove(E e):把给定的对象在当前集合中删除。
public boolean contains(E e):判断当前集合中是否包含给定的对象。
public boolean isEmpty():判断当前集合是否为空。
public int size():返回集合中元素的个数。
public object[] toArray():把集合中的元素，存储到数组中。

public class demoCollection {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();//多态
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("唐七");

        System.out.println(list);//[张三, 李四, 王五, 赵六, 唐七]
        list.remove("王五");
        System.out.println(list);//[张三, 李四, 赵六, 唐七]
        boolean b = list.contains("张三");
        System.out.println(b);//true
        boolean b1 = list.isEmpty();
        System.out.println(b1);//true
        int size = list.size();
        System.out.println(size);//4
        Object[] array = list.toArray();
        System.out.println(array[0]);//张三
        list.clear();
        System.out.println(list);//[]

    }
}

迭代器

java.util.iterator接口:迭代器(对集合进行遍历)有两个常用的方法
booLean hasNext(）如果仍有元素可以迭代，则返回true。
E next() 返回迭代的下一个元素。取出集合中的下一个元素

Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,
获取实现类的方式比较特殊collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象。
Iterator iterator(）返回在此collection的元素上进行迭代的迭代器。
迭代器的使用步骤(重点)∶
1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
2.使用Iterator接口中的方法hasNext为断还有没有下一个元素
3.使用Iterator接口中的方法next取出集合中的下一个元素

public class demoIterator {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("姚明");
        coll.add("科比");
        coll.add("詹姆斯");
        coll.add("乔丹");
        coll.add("麦迪");


        Iterator<String> it = coll.iterator();//调用Collection的iterator()方法返回迭代器对象


        while (it.hasNext()){//迭代器遍历集合
            String s = it.next();
            System.out.println(s);
        }
    }
}

增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写是JDK1.5之后出现的新特性
collectionextends Iterable:所有的单列集合都可以使用增强for。
public interface Iterable实现这个接口允许对象成为“foreach”语句的目标。
增强for循环:用来遍历集合和数组。

        for (Iterator<String> it1 = coll.iterator();it1.hasNext();){//一般for
            String s = it1.next();
            System.out.println(s);
        }

        for(String s:coll ){//增强for
            System.out.println(s);

        }

List

List的两个重要实现类ArrayList和LinkedList：
在这里插入图片描述
ArrayList的优势是查询快，支持随机访问。

LinkedList的优势是删除和添加。但是查询慢。
List的常用操作:

add(obj) 添加元素
get(i) 查看第i个元素
size() 查看列表中的数据个数
isEmpty() 判断是否是空列表
indexOf(xxx) 查看xxx元素在列表中的位置
lastIndexOf(xxx) 查看xxx元素在列表中最后一次出现的位置
contains(xxx) 判断列表中是否包含了xxx
subList(start. end) 从列表中start开始截取, 截取到end 但不包括end
toArray() 转化成数组
remove(obj) 删除某个元素
remove(i) 删除某个位置的元素

Set

Set是一个可以自动去除重复的容器. set内部你可以认为有一个安检员. 发现重复的了就拦在外面。

Set是一个接口. 有两个常用的实现类. 一个是HashSet, 另一个是TreeSet。HashSet按照Hash的想法来放数据, TreeSet按照Tree的思想来存放数据。 HashSet无序->存储的速度快, TreeSet按顺序摆->存储的时候帮你排序, 存储的速度就慢。

java.util.set接口extends collection接口set接口的特点:
1.不允许存储重复的元素
2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
java.util.Hashset集合implements set接口
HashSet特点:
1.不允许存储重复的元素
2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构(查询的速度非常的快)

Hashset存储自定义类型元素
set集合报错元素唯一:
存储的元素(String,Integer , . . .Student , Person…)引用类型,必须在对应类中重写hashcode方法和equals方法

Set的常用方法:

add() 添加元素
remove() 删除元素
size() 集合中元素的个数
contains() 判断是否包含了xxxx

public class demo01HashSet {
    public static void main(String[] args) {
    
        Person p1 = new Person("周杰伦",18);
        Person p2 = new Person("周杰伦",18);
        Person p3 = new Person("周杰伦",19);

        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        /*
        未重写toString方法
        [tl.study2.collection.set.demo01HashSet.Person@13b6d03, tl.study2.collection.set.demo01HashSet.Person@282ba1e, tl.study2.collection.set.demo01HashSet.Person@75412c2f]
        * */
        System.out.println(set);//[Person{name='周杰伦', age=18}, Person{name='周杰伦', age=19}]
        System.out.println("p1"+p1.hashCode());//hashcode:p1669800309
        System.out.println("p2"+p2.hashCode());//hashcode:p2669800309
        System.out.println("p3"+p3.hashCode());//hashcode:p3669800310
//        必须重写hashcode方法和equals方法


    }

    public static class Person {
        private String name;
        private int age;

        public Person() {
        }

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

        ***@Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age && Objects.equals(name, person.name);
        }***

        @Override
        public int hashCode() {
            return Objects.hash(name, 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;
        }
    }
}

Map

java.util.Map<k, v>集合Map集合的特点∶

Map集合是一个双列集合，一个元素包含两个值(一个key,一个value)
Map集合中的元素,key和value的数据类型可以相同,也可以不同
Map集合中的元素,key是不允许重复的, value是可以重复的
Map集合中的元素, key和value是一一对应

java.util.HashMap<k, v>集合 implements Map<k, v> 接口HashMap集合的特点:

1.HashMap集合底层是哈希表:查询的速度特别的快。JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8):提高查询的速度
2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致

java.util.LinkedHashMap<k , v>集合 extends HashMap<k , v>集合
LinkedHashMap的特点:

1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashNap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

常用方法
在这里插入图片描述

更多方法

Map的遍历

Map集合的第一种遍历方式:通过键找值的方式Map集合中的方法:
set keySet()返回此映射中包含的键的Set视图。
实现步骤:

1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个set集合中
2.遍历set集合,获取map集合中的每一个key
3.通过Map集合中的方法get( key),通过key找到value

public class demoKeySet {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("黄晓明", "杨颖2");
        map.put("杨过", "小龙女");
        map.put("尹志平", "小龙女");

        Set<String> keySet = map.keySet();

        //使用迭代器
        Iterator<String> it = keySet.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"="+map.get(s));
        }
        //使用增强for
        for(String s:keySet){
            System.out.println(s+"="+map.get(s));
        }

        //增强for
        for (String key : map.keySet()) {
            System.out.println(key + "=" + map.get(key));
        }


    }
}

Map集合遍历的第二种方式:使用Entry对象遍历
Map集合中的方法:
set<Nap.Entry<K,V>> entrySet(）返回此映射中包含的映射关系的 Set视图。
实现步骤:

1.使用wap集合中的方法entrySet( ),把Map集合中多个Entry对象取出来,存储到一个set集合中
2.遍历set集合,获取每一个Entry对象
3.使用Entry对象中的方法getKey()和getValue()获取键与值*/

public class demoEntrySet {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("赵丽颖",168);
        map.put("杨颖",169);
        map.put("迪丽热巴",180);
        map.put("古力娜扎",156);

        Set<Map.Entry<String, Integer>> entries = map.entrySet();

/*        Iterator<Map.Entry<String, Integer>> it = entries.iterator();
        while (it.hasNext()){
            Map.Entry<String, Integer> entry = it.next();
            System.out.println(entry.getKey()+"="+entry.getValue());
        }*/
        for (Map.Entry<String, Integer> entry:map.entrySet()){
//            System.out.println();
            System.out.println(entry.getKey()+"="+entry.getValue());

        }
    }
}

谢谢我不玩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java容器

文章目录java容器的类型Set和List的区别Collection接口迭代器Listjava容器的类型如上图所示Java的容器主要继承Collection接口和Map接口：Set和List的区别Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长
复制链接

扫一扫