栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

集合泛型总结

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

集合泛型总结

集合泛型

集合类的特点:提供一种存储空间可变的存储类型,存储的数据容量可以随时发生改变

  1. Collection

  2. List

  3. Set

  4. 泛型

  5. Map

  6. Collections

ArrayList

集合类有很多,such as ArrayList

Collection

//通过集合对象获取迭代器对象;Iterator是接口;iterator是继承接口的类的实现对象
package com.xm.study.collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class A {
    public static void main(String[] args) {
        Collection collection=new ArrayList<>();
        collection.add("你好吗");
        collection.add("我很好");
        System.out.println(collection.add("我也是"));
        System.out.println(collection);
        //通过集合对象获取迭代器对象;Iterator是接口;iterator是继承接口的类的实现对象
        Iterator iterator = collection.iterator();
​
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
         for (String s : collection)
        {
            System.out.println(s);
        }
        collection.remove("你好吗");
        System.out.println(collection.size());
​
​
​
    }
}
​
List

list 集合中的方法 Array list中一定有,而Collection中不一定有:

set,get等等

package com.xm.study.list;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
​
public class A {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("你好吗");
        list.add("我很好");
        list.add("我也是");
        list.add("我很好");
        Iterator iterator = list.iterator();
        ListIterator listIterator = list.listIterator();
        System.out.println(list);
        list.add(1, "world");
        System.out.println(list.remove(1));
        System.out.println(list.set(1, "是"));
        System.out.println(list.get(1));
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            System.out.print(str + " ");
        }
​
​
    }
}
​

当我们在遍历实现了collection接口与iterator接口的集合时(List、Set、Map), 我们可以通过遍历索引也可以通过迭代器进行遍历。在我们使用迭代器进行遍历集合的时候,会获取到当前集合的迭代对象。在里面有封装了迭代器的remove方法与集合自带的remove方法,如果我们调用迭代器对象的remove方法是没问题的,但是当我们调用集合自带的remove方法时,就会产生Concurrent Modification Exception 并发修改异常。

Iterator

迭代器遍历过程中,通过集合对象修改了集合中的元素的长度,造成了迭代器获取元素中 判断预期修改值和现实修改值不一致

解决方案:用for循环遍历,然后用集合对象做对应的操作即可

package com.xm.study.list;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class concurrentException {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("你好吗");
        list.add("我很好");
        list.add("我也是");
        Iterator iterator = list.iterator();
        //list.add("what");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        list.add("what");
        for (int i = 0; i < list.size(); i++) {
             System.out.println(list.get(i));
        }
​
​
    }
}
​
List Iterator迭代器

解决了并发问题

通过List 集合的list Iterator()方法得到,所以它是List集合特有的迭代器

package com.xm.study.list;
​
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
​
public class listIterator {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("你好吗");
        list.add("我很好");
        list.add("我也是");
        ListIterator listIterator = list.listIterator();
        listIterator.add("name");
​
        while (listIterator.hasNext()) {
            if (listIterator.next().equals("我很好")) {
                listIterator.add("nb");
            }
        }
        System.out.println(list);
    }
}
​

增强for循环:内部原理是一个Iterator迭代器;

实现Iterable接口的类允许其对象成为for语句的目标

for(String element:list) {
           if (element.equals("我很好")) {
                list.add("nb");
            }
}
所以出错 Concurrent Modification Exception 
    
    
    
while (listIterator.hasNext()) {
            if (listIterator.next().equals("我很好")) {
                listIterator.add("nb");
            }
}
正确;

数组:查询快,增删慢;

链表: 查询慢,增删快;

Array List 底层原理是数组;

Linked List 底层原理是双链表;

Linked List

package com.xm.study.list;
​
import java.util.LinkedList;
​
public class linkedList {
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList<>();
        linkedList.add("肖猛");
        System.out.println(linkedList);
        linkedList.addFirst("李伟晴");
        System.out.println(linkedList);
        linkedList.addLast("东旭");
        System.out.println(linkedList);
        System.out.println(linkedList.lastIndexOf("东旭"));
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        System.out.println(linkedList.remove("东旭"));
        System.out.println("---------");
        System.out.println(linkedList.remove());
        System.out.println(linkedList);
​
​
    }
}
​
Set

Set接口继承Collection接口

HashSet

底层的原理是哈希表;不能通过索引遍历,可以迭代器和增强型for循环

HashSet类的底层结构是哈希表;

LinkedHashSet

LinkedHashSet类继承HashSet类:底层结构是哈希表和链表;

  • 它维护了一个贯穿其所有条目的双向链表。 此链接列表定义迭代排序,即元素插入集合( 插入顺序 ) 的顺序 。

  • 此实现使客户免于HashSet提供的未指定的,通常是混乱的排序,而不会导致与TreeSet相关的增加的成本。无论原始集合的实现如何,它都可用于生成与原始集合具有相同顺序的集合的副本:

TreeSet

TreeSet 间接使用Set接口,无索引,底层原理是红黑树

自然排序Comparable

  • 此接口对实现它的每个类的对象强加一个总排序。 这种排序被称为类的自然排序 ,类的compareTo方法被称为其自然比较方法 。

  • 按字典顺序比较两个字符串,忽略大小写差异。此方法返回一个整数,其符号是调用compareTo的整数,其中字符串的规范化版本通过在每个字符上调用Character.toLowerCase(Character.toUpperCase(character))消除了大小写差异。

  • 请注意,此方法不场所考虑,并会导致特定的语言环境不满意的排序。 java.text包提供了collators以允许区分设置敏感的排序。

Student

package com.xm.study.set;
​
public class Student  implements Comparable{
    String name;
    int age;
​
    public String getName() {
        return name;
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public int compareTo(Student s) {
//        if (this.age - s.age > 0)
//            return 1;
//        else if (this.age - s.age < 0)
//            return -1;
//        else {
//            return Character.compare(this.getName().charAt(0), s.getName().charAt(0));
//        }
        
        int num=this.age-s.age;
        return  num==0?this.name.compareTo(s.name):num;
​
​
​
​
    }
}
​

Comparable

package com.xm.study.set;
​
import java.util.TreeSet;
​
//优先年龄从小到达,名字字母排序
public class TestComparable {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet<>();
        Student s1=new Student("b肖猛",12);
        Student s2=new Student("a李伟晴",12);
        Student s3=new Student("刘东旭",14);
        Student s4=new Student("罗鑫洋",15);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        for(Student student:ts)
        {
            System.out.println(student.getName()+student.getAge());
        }
    }
}
​

比较排序Comparator

Student

package com.xm.study.set;
​
public class Student {
    String name;
    int age;
​
    public String getName() {
        return name;
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}
​
    

Comparator

package com.xm.study.set;
​
import java.util.Comparator;
import java.util.TreeSet;
​
public class TestComparator {
    public static void main(String[] args) {
        
        TreeSet ts = new TreeSet<>((o1, o2) -> {
            int num = o1.getAge() - o2.getAge();
            return num == 0 ? o1.getName().compareTo(o2.getName()) : num;
​
        });
        Student s1=new Student("b肖猛",12);
        Student s2=new Student("a李伟晴",12);
        Student s3=new Student("刘东旭",14);
        Student s4=new Student("罗鑫洋",15);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        for(Student student:ts)
        {
            System.out.println(student.getName()+student.getAge());
        }
    }
}
​

成绩比较类

package com.xm.study.set;
import java.util.TreeSet;
​
public class 成绩比较类 {
    public static void main(String[] args) {
    
        TreeSet ts=new TreeSet<>((s1,s2)->{
            int num=(s2.getMath()+s2.getChinese())-(s1.getChinese()+s1.getMath());
            int num1=num==0?s2.getChinese()-s1.getChinese():num;
            int num2=num1==0?s2.getName().compareTo(s1.getName()):num1;
            return num2;
        });
        Student2 s1=new Student2("肖猛",100,400);
        Student2 s3=new Student2("李伟晴",150,50);
        Student2 s2=new Student2("李振宇",150,50);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        for(Student2 s:ts)
        {
            System.out.println(s.getName());
        }
​
    }
}
​

产生随机数

Hash set不会排序

Tree set会排序

package com.xm.study.set;
​
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
​
public class 随机数 {
    public static void main(String[] args) {
        Set set= new TreeSet<>();
        Random r=new Random();
        while(set.size()<10)
        {
            int num=r.nextInt(20)+1;
            set.add(num);
        }
        for(Integer i:set)
        {
            System.out.println(i);
        }
​
    }
}
​
泛型 泛型定义

类型通配符

list代表元素类型未知的List,他的元素可以匹配任意类型;

List 类型通配符上限:List他代表的类型是Number或Integer

List类型通配符下限:List他代表的是Number或Object

可变参数

可变参数的定义

多个参数的情况下,可变参数要放在后边

具体实现:

package com.xm.study.泛型;
​
import java.util.Arrays;
import java.util.List;
import java.util.Set;
​
public class 可变参数 {
    public static void main(String... args) {
        List list = Arrays.asList("你好", "我不好", "桥梁");
//        list.add("瓦胡同");
//        list.remove("你好");不能改变大小;
        list.set(1, "nb ");
        System.out.println(list);
        List list2 = List.of("你好", "我不好", "桥梁");
//        list.add("瓦胡同");
//        list.remove("你好");不能改变大小和值;
//        list.set(1, "nb ");
        System.out.println(list2);
        Set set=Set.of("你好", "我不好", "桥梁");
//        set.add("瓦胡同");
//        set.remove("你好");不能改变大小和值;
//          set.set();Set接口没有索引所以没有set 方法
        System.out.println(set);
​
​
    }
}
​
Map

功能
package com.xm.study.Map;
​
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class 获取功能 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("肖猛", 12);
        map.put("李伟晴", 15);
        map.put("肖紫嫣", 6);
        System.out.println(map.get("肖猛"));
        Set set = map.keySet();//获取键
        System.out.println(set);
        for (String s : set)
            System.out.println(s);
        Collection collection = map.values();//获取值
        System.out.println(collection);
        for (Integer i : collection)
            System.out.println(i);
        //获取键和值
        Set> entrySet = map.entrySet();
        for(Map.Entry element:entrySet)
        {
            System.out.println(element.getKey()+element.getValue());
        }
​
    }
}
​
遍历
package com.xm.study.Map;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class Student遍历 {
    public static void main(String[] args) {
        Map map=new HashMap<>();
        Student s1=new Student("肖猛",12);
        Student s2=new Student("东旭",13);
        Student s3=new Student("肖紫嫣",10);
        map.put("1号",s1);
        map.put("2号",s2);
        map.put("3号",s3);
        //遍历1
        Set keySet = map.keySet();
        for(String key:keySet)
        {
            System.out.println(key+map.get(key).getName()+map.get(key).getAge());
        }
        System.out.println("---------");
        //遍历2
        Set> entries =  map.entrySet();
        for(Map.Entry element :entries)
        {
//            System.out.println(element.toString());
            System.out.println(element.getKey()+element.getValue().getName()+element.getValue().getAge());
        }
​
    }
}
​
Array List集合存储Hash Map元素并遍历
package com.xm.study.Map;
​
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class ArrayList存储HashMap元素并遍历 {
    public static void main(String... args) {
        Map map1 = new HashMap<>();
        map1.put("01", "肖猛");
        map1.put("02", "李伟晴");
        map1.put("03", "what");
        Map map2 = new HashMap<>();
        map2.put("01", "肖猛1");
        map2.put("02", "李伟晴1");
        map2.put("03", "what1");
        Map map3 = new HashMap<>();
        map3.put("01", "肖猛2");
        map3.put("02", "李伟晴2");
        map3.put("03", "what2");
        ArrayList> arrayList = new ArrayList<>();
        arrayList.add(map1);
        arrayList.add(map2);
        arrayList.add(map3);
        for (Map map : arrayList) {
            //element就是HashMap的实例化对象==map
            Set> entries = map.entrySet();
            for (Map.Entry KandV : entries) {
                //elements就是HashMap中的元素==map中的元素包含Key和Value
                System.out.println(KandV.getKey() + KandV.getValue());
            }
        }
    }
}
​
Hash Map 集合存储Array List元素并遍历
package com.xm.study.Map;
​
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class HashMap存储ArrayList元素并遍历 {
    public static void main(String[] args) {
        Map> map = new HashMap<>();
        ArrayList arrayList = new ArrayList<>();
        ArrayList arrayList1 = new ArrayList<>();
        ArrayList arrayList2 = new ArrayList<>();
        arrayList.add("你好嘛");
        arrayList.add("我很好");
        arrayList.add("你呢");
        arrayList.add("我也是");
        arrayList1.add("你好嘛1");
        arrayList1.add("我很好1");
        arrayList1.add("你呢1");
        arrayList1.add("我也是1");
        arrayList2.add("你好嘛2");
        arrayList2.add("我很好2");
        arrayList2.add("你呢2");
        arrayList2.add("我也是2");
        map.put(1, arrayList);
        map.put(2, arrayList1);
        map.put(3, arrayList2);
        //方式一
        Set>> entrySet = map.entrySet();
        for (Map.Entry> element : entrySet) {
            int key = element.getKey();
            ArrayList value = element.getValue();
            System.out.println("键为" + key + "对应为arraylist" + (key - 1) + "集合");
            System.out.println("此集合中对应的元素:");
            for (String s : value)
                System.out.print(s + " ");
            System.out.println();
        }
        System.out.println("-----------------------");
        //方式二
        Set keySet = map.keySet();
        for(Integer i :keySet)
        {
            System.out.println("键为" + i + "对应为arraylist" + (i - 1) + "集合");
            ArrayList list = map.get(i);
            for(String s:list)
            {
                System.out.println("键"+i+"对应的集合中的元素:"+s);
            }
        }
​
    }
}
​
Collections工具类 功能:
package com.xm.study.Collections;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
​
public class A {
    public static void main(String[] args) {
        List list=new ArrayList<>();
        list.add(30);
        list.add(20);
        list.add(40);
        list.add(30);
        list.add(10);
        list.add(70);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        //随机置换
        Collections.shuffle(list);
        System.out.println(list);
​
​
    }
}
​

Array List中的排序:
package com.xm.study.Collections;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
​
public class Demo1 {
    public static void main(String... args) {
        ArrayList arrayList=new ArrayList<>();
        Student s1=new Student("liumeng",40);
        Student s2=new Student("abcdye",40);
        Student s3=new Student("xiaomeng",40);
        Student s4=new Student("weare",40);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        Collections.sort(arrayList, (Student thiss, Student befores)-> {
                int num=thiss.getAge()-befores.getAge();
                int num2=num==0?thiss.getName().compareTo(befores.getName()):num;
                return num2;
            }
        );
        for(Student student:arrayList)
            System.out.println(student.getName()+student.getAge());
    }
}
​

未排序斗地主:
package com.xm.study.Collections;
​
import java.util.ArrayList;
import java.util.Collections;
​
public class FightTheLandlord {
    public static void main(String[] args) {
        ArrayList array = new ArrayList<>();
        String[] color = {"♦", "♥", "♣", "♠"};
        String[] number = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
        String bigBos = "大王", smallBos = "小王";
        for (String colors : color)
            for (String num : number)
                array.add(colors + num);
        array.add(bigBos);
        array.add(smallBos);
        Collections.shuffle(array);
        ArrayList number1 = new ArrayList<>();
        ArrayList number2 = new ArrayList<>();
        ArrayList number3 = new ArrayList<>();
        ArrayList diPai = new ArrayList<>();
        for (int i = 0; i < array.size(); i++) {
            String poKer = array.get(i);
            if (i >= array.size() - 3)
                diPai.add(poKer);
            else if (i % 3 == 0)
                number1.add(poKer);
            else if (i % 3 == 1)
                number2.add(poKer);
            else
                number3.add(poKer);
        }
        ShowPoKer("肖猛:", number1);
        ShowPoKer("李伟晴:", number2);
        ShowPoKer("东旭:", number3);
        ShowPoKer("底牌:", diPai);
​
    }
​
    public static void ShowPoKer(String name, ArrayList array) {
        System.out.print(name + "的牌示:");
        for (String poker : array)
            System.out.print(poker + " ");
        System.out.println();
    }
}
​
肖猛:的牌示:♣6 ♠Q ♥10 ♠10 ♥8 ♣5 ♦9 ♣7 ♠K ♥A ♠6 ♣10 ♠5 ♥6 ♠8 ♣A ♦K 
李伟晴:的牌示:♣4 小王 ♦3 ♣J ♥5 ♠A ♣K ♣9 ♦J ♠4 ♦4 ♦2 ♠9 ♥9 ♦8 ♦5 ♠J 
东旭:的牌示:♦10 ♥Q 大王 ♠3 ♥7 ♦Q ♥J ♠7 ♥K ♦A ♥3 ♠2 ♣3 ♣2 ♦7 ♥4 ♦6 
底牌:的牌示:♥2 ♣Q ♣8 

排序斗地主:
 package com.xm.study.Collections;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
​
public class UpGradeLandlords {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        ArrayList array = new ArrayList<>();
        String[] colors = {"♦", "♥", "♣", "♠"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        int index = 0;
        for (String num : numbers)
            for (String color : colors) {
                map.put(index, color + num);
                array.add(index);
                index++;
            }
        map.put(index, "小王");
        array.add(index);
        map.put(index + 1, "大王");
        array.add(index + 1);
        Collections.shuffle(array);
        TreeSet player1 = new TreeSet<>();
        TreeSet player2 = new TreeSet<>();
        TreeSet player3 = new TreeSet<>();
        TreeSet diPai = new TreeSet<>();
        for (int i = 0; i < array.size(); i++) {
            int x = array.get(i);
            if (i >= array.size() - 3)
                diPai.add(x);
            else if (i % 3 == 0)
                player1.add(x);
            else if (i % 3 == 1)
                player2.add(x);
            else
                player3.add(x);
        }
        ShowPoKer("肖猛:", player1, map);
        ShowPoKer("李伟晴:", player2, map);
        ShowPoKer("东旭:", player3, map);
        ShowPoKer("底牌:", diPai, map);
    }
​
    public static void ShowPoKer(String name, TreeSet treeSet, HashMap map) {
        System.out.print(name + "的牌示:");
        for (int key : treeSet)
            System.out.print(map.get(key) + " ");
        System.out.println();
    }
​
}
​
肖猛:的牌示:♣3 ♠4 ♦5 ♠5 ♥6 ♣7 ♦8 ♦9 ♥9 ♠9 ♣10 ♣J ♦Q ♥Q ♠Q ♥A ♥2 
李伟晴:的牌示:♥3 ♦4 ♣4 ♣6 ♥7 ♠7 ♠8 ♣9 ♥10 ♠10 ♥J ♣Q ♥K ♣K ♦2 ♣2 ♠2 
东旭:的牌示:♦3 ♠3 ♥4 ♥5 ♣5 ♦6 ♠6 ♣8 ♦10 ♦J ♠J ♦K ♠K ♦A ♠A 小王 大王 
底牌:的牌示:♦7 ♥8 ♣A 

异常处理

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/981089.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号