首页 > > 程序设计 > Java技术 >

JavaSE笔记-集合

2018-06-18 03:31:22来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

Java集合大致可分为：List,Set,Map,Queue

List:有序，可重复

Set:无序（输出和插入顺序不一定一致），不可重复

Map:映射关系,根据key去访问value

Queue:队列，先进先出(FIFO)

集合类只能存储对象

List<int>       //错误 
List<Integer>

Collection体系结构

 

圆圈表示:interface

长方形表示：class

带三角的实线代表继承关系，使用关键字extends

带三角的虚线代表实现关系，使用关键字implements

Iterable

iterable定义了iterator()，forEach(Consumer<? super T> action)

这2个方法用于遍历元素

1.forEach方法遍历集合

Consumer是一个函数式接口，只有一个accept(T t)方法，可以使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new HashSet<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //使用forEach遍历集合
        coll.forEach(name->System.out.println(name));
    }

 输出（因为HashSet并未实现SortedSet接口，所以里边的元素是无序的）

2.iterator()遍历集合

 集合类使用iterator()方法，会返回一个Iterator

Iterator接口主要用于遍历Collection中的元素

有上边的4个方法，其中forEachRemaining()用来使用Lambda表达式来遍历集合

　　2.1不使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //获得一个iterator
        Iterator<String> iterator = coll.iterator();
        //iterator中是否还有下一个元素
        while(iterator.hasNext()){
            //返回集合中的下一个元素
            String name = iterator.next();
            System.out.println(name);
            //删除一个元素
            if("小王5".equals(name)){
                iterator.remove();
            }
            //更改iterator中元素，但是集合中的元素没有改变
            //因此可以得出集合传给iterator的是元素的值，而不是引用
            name = "李四";
        }
        System.out.println(coll.contains("小王5"));
    }

注意在使用iterator迭代集合元素的过程中（不要在while循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException

　　2.2使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //获得一个iterator
        Iterator<String> iterator = coll.iterator();
        iterator.forEachRemaining(name->System.out.println(name));
    }

3.使用foreach循环来遍历元素

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        
        for(String name:coll){
            System.out.println(name);
        }
}

注意在使用foreach遍历集合元素的过程中（不要在for循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException

Collection

Collection中的操作可以操作所有的List,Set,Queue

   public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加一个元素
        coll.add("张三");
        //返回true
        System.out.println(coll.contains("张三"));
        //返回1
        System.out.println(coll.size());
        //删除元素
        coll.remove("张三");
        //返回0
        System.out.println(coll.size());
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //把集合转换成数组
        String[] array = coll.toArray(new String[10]);
        System.out.println(array[5]);
    }

 Set

特点是不允许包含重复元素，继承自Collection接口，没有添加额外方法

1.HashSet

特点

不保证有序

线程不安全，有2个线程同时修改HashSet时，需要通过代码同步

集合元素可以是null

数据结构：散列表
HashSet判定2个元素相等的条件是：1.equals()方法比较相等　　2.hashCode()返回值相等

class A{
    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

class B{
    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

class C{
    @Override
    public int hashCode() {
        return 2;
    }
}
public class Test {
    public static void main(String[] args){
        Set<Object> set = new HashSet<>();
        //仅equals()相同
        set.add(new A());
        set.add(new A());
        //hashCode(),equals()均相同
        set.add(new B());
        set.add(new B());
        //仅hashCode()相同
        set.add(new C());
        set.add(new C());
        for(Object a : set){
            System.out.println(a);
        }
    }

输出

可以看出只有B,equals和hashCode都相同时，HashSet才会认为这2个元素使同一个元素

当hashCode相同时，HashSet会把多个元素放在一个bucket中，构成同义词链表，会减慢访问速度

因此，使用HashSet时，要保证2个对象equals返回true时，hashCode也要返回true

2.TreeSet

特点

排过序

线程不安全，有2个线程同时修改HashSet时，需要通过代码同步

数据结构：红黑树

TreeSet的排序规则

　　2.1自然排序 （默认）

调用集合元素的compareTo(Object obj)方法比较元素大小关系，然后按元素大小升序排列

a.compareTo(b)

a>b,返回正数

a=b,返回0

a<b,返回负数

使用TreeSet时，要保证2个对象equals返回true时，a.compareTo(b)要返回0

因此在向TreeSet中添加元素时，要实现Comparable接口，否则抛出ClassCashException

    public static void main(String[] args){
　　　　　//Integer已经实现Comparable接口
        TreeSet<Integer> set = new TreeSet<>();
        set.add(5);
        set.add(4);
        set.add(9);
        set.add(2);
        for(Integer i : set){
            System.out.println(i);
        }
    }

输出

　　2.2通过Comparator接口（函数式接口）

　　

compare(a,b)

返回正数,a>b

返回0,a=b

返回负数,a<b

实现逆序，返回相反的数就行了

    public static void main(String[] args) {
　　　　 //使用TreeSet(Comparator<? super E> comparator)构造
        TreeSet<Integer> set = new TreeSet<>(
                (num1,num2)-> {
                    if (num1 < num2)
                        return 1;
                    if(num1 > num2)
                        return -1;
                    return 0;
                }
        );
        set.add(9);
        set.add(1);
        set.add(3);
        for (int num : set){
            System.out.println(num);
        }
    }

输出

3.EnumSet

　　所有元素必须是enum类型

　　EnumSet是有序的

　　不允许放入null

　　没有构造器， 通过静态方法获得EnumSet

List

特点是元素有序，可重复，继承自Collection接口，还添加了一些根据索引操作元素的方法

　　List判断2个元素相等的条件是equals方法返回true

set方法只能用于修改集合中已经存在的值，不能新增加元素。

使用List的sort方法进行排序

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李小四");
        list.add("王大少爷");
        //集合的顺序是张三，李小四，王大少爷
        list.sort(
                ((o1, o2) ->{
                    if(o1.length() < o2.length())
                        return 1;
                    if(o1.length() == o2.length())
                        return 0;
                    return -1;
                } )
        );
        for (String s: list) {
            System.out.println(s);            
        }
    }

 输出

 使用ListIterator迭代

ListIterator()方法返回一个ListIterator,ListIterator增加了向前迭代元素的方法，以及添加元素的方法

   public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李小四");
        list.add("王大少爷");
        //集合的顺序是张三，李小四，王大少爷
        ListIterator<String> listIterator = list.listIterator();
        //注意这里调用add方法采用的是头插法
        listIterator.add("周杰伦");
        System.out.println(list);
        while(listIterator.hasNext()){
            listIterator.next();
        }
        System.out.println("你还想怎么样啊，到底了");
        System.out.println("========================");
        System.out.println("我还能反着遍历元素啊");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }

输出

 ArrayList,Vector

ArrayList,Vector是List的2个典型实现，调用不带参数构造方法，initialCapacity=10；带参数的构造方法，自己指定initialCapacity

ArrayList不是线程安全的，Vector是线程安全的

Queue

数据结构：队列（FIFO）

不允许随机访问

element()方法返回头元素，不删除集合中元素

peek()方法返回头元素或者null，不删除集合中元素

poll()方法返回头元素或者null,删除集合中元素

1.PriorityQueue

　　按元素大小重新排序，因此取出头元素时，是最小的元素

　　PriorityQueue不允许插入null

　　PriorityQueue对元素的排序方法同样有2种，自然排序和定制排序，思路和TreeSet一样

2.Deque和ArrayDeque

　　Deque代表一个双端队列

 

它们功能相同，区别是对失败情况的处理不同。一套接口遇到失败就会抛出异常，另一套遇到失败会返回特殊值（false或null）

　　ArrayDeque底层也是数组，数组长度默认是16

ArrayDeque可以作为栈和队列使用（推荐）

作为栈时使用下面2个方法操作元素

作为队列时使用下面方法操作元素

LinkedList

　　实现了List和Deque 2个接口，底层是链表，随机访问效率较差，插入删除效率高

　　LinkedList采用迭代器方式遍历效率高，ArrayList,Vector使用get效率高

 

Map体系结构

 

 Map

　　Key:无序，不可重复->组成一个keySet

　　Value:有序，可重复->组成一个List

   public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        //添加元素
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        //key是唯一的，如果放入相同的key，会把现有的覆盖
        map.put(3,"赵子龙");
        //输出赵子龙
        System.out.println(map.get(3));
        //删除赵子龙
        map.remove(3);
        //遍历
        for (int i : map.keySet()){
            System.out.println(map.get(i));
        }

    }

HashMap,Hashtable

　　区别：1.HashMap线程不安全，Hashtable线程安全

　　　　　2.HashMap可以使用null作为key和value（由于key是不可重复的，因此key只能有1个可以为null，value可以有无数个），Hashtable不可以

　　判定key和value是否相等

　　判定key相等通过equals()方法和hashCode()方法，判定value相等通过equals()方法

　

class MyKey{
    private int key;

    public MyKey(int key){
        this.key = key;
    }
    @Override
    public boolean equals(Object obj) {
        MyKey k = (MyKey) obj;
        if(key == k.key)
        return true;
        return false;
    }

    @Override
    public int hashCode() {
        return key;
    }
}
public class Test {
    public static void main(String[] args){
        Map<MyKey,String> map = new HashMap<>();
        map.put(new MyKey(1),"张三");
        map.put(new MyKey(2),"李四");
        //key相同，会覆盖原来的
        map.put(new MyKey(1),"周杰伦");
        //输出{MyKey@1=周杰伦, MyKey@2=李四}
        System.out.println(map);
        //返回true
        System.out.println(map.containsValue("李四"));
    }
}

LinkedHashMap

　　LinkedHashMap使用双向链表维护key,确保key插入顺序与迭代顺序一致

Properties

　　Properties相当于一个key,value都是String的Map

　　使用Properties读取配置文件

    public static void main(String[] args){
        Properties properties = new Properties();
        try {
            properties.load(new InputStreamReader(new FileInputStream("properties"),"utf-8"));
            System.out.println(properties);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 TreeMap

　　数据结构：红黑树

　　每个key-value对作为红黑树节点

　　2种排序方式：自然排序和定制排序（看key，与TreeSet判等规则一致）

WeakHashMap

　　与HashMap区别：WeakHashMap的key中保存的是弱引用，HashMap中保存的是强引用

　　如果WeakHashMap中的key没有被其他强引用变量引用，这些key有可能被GC回收

IdentityHashMap

　　与HashMap区别：IdentityHashMap只有当key1 == key2 才认为2个key相等，HashMap两个key的equals,hashCode相等即相等

工具类Collections

　对List的操作

 public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        for (int i=0; i<10;i++){
            list.add(i);
        }
        //输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        System.out.println(list);
        //逆序
        Collections.reverse(list);
        //输出[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
        System.out.println(list);
        //随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //升序排序
        Collections.sort(list);
        System.out.println(list);
        //二分查找指定元素位置，List必须有序
        System.out.println(Collections.binarySearch(list,5));
    }

　　查找Collection最大最小值

    public static void main(String[] args){
        Collection<Integer> c = new HashSet<>();
        for (int i=0;i<10;i++){
            c.add(i);
        }
        //最大值9
        System.out.println(Collections.max(c));
        //最小值0
        System.out.println(Collections.min(c));
    }

　　同步集合

　　

通过上面3个方法得到同步后的集合，确保线程安全

 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Servlet案例1：用户登录

下一篇：maven(项目管理工具系列 maven 总结二)

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签