精华内容
下载资源
问答
  • Java中的ArrayList集合定义、遍历、方法
    万次阅读
    2018-05-11 20:38:11

    /*

        一、定义

    ArrayList集合的使用
    是引用数据类型
    实用的步骤:
    1.导入包 java.util包中
    2.创建引用类型的变量
    数据类型<集合储存的数据类型> 变量名 = new 数据类系<集合储存的数据类型>();
    集合储存的数据类型:要将数据存储到集合的容器中(因为数组和集合都是容器),
    所以在创建集合引用变量的时候,必须要指定好储存的类型是什么

    ArrayList<String> array = new ArrayList<String>();

    3.变量名.方法名

    注意:集和储存的数据,8个基本类型对应8个引用类型
    储存引用类型,不储存基本类型


    */
    import java.util.ArrayList;
    public class ArrayListDemo{
    public static void main(String[] args){
    //创建集合容器,指定储存的数据类型
    //储存字符串
    ArrayList<String> array = new ArrayList<String>();

    //创建集合容器,储存整数
    ArrayList<Integer> array2 = new ArrayList<Integer>();

    //创建集合容器,储存手机类型
    ArrayList<Phone> array3 = new ArrayList<Phone>();
    }

    }


    --------------------------------------------------------------------------------

    /*

    二、方法

            ArrayList集合中的方法


    add(参数) 向集合中添加元素,数据存储进去
    方法中的参数类型,和定义几何对象时的类型必须一致

    ArrayList<Integer> array = new ArrayList<Integer>();
    array.add(3);

    get(int index) 取出集合中的元素,get方法的参数写入索引

    size() 返回集合的长度,集合存储元素的个数
    */
    import java.util.ArrayList;
    public class ArrayListDemo_1{
    public static void main(String[] args){
    //定义集合,储存字符串元素
    ArrayList<String> array = new ArrayList<String>();
    //调用集合方法add存储元素
    array.add("abc");
    array.add("itcast");
    array.add("love");
    array.add("java");
    //输出集合的长度,调用集合方法size
    int size = array.size();
    System.out.println(size);
    //取出集合中的元素,调用集合方法get
    String arr = array.get(3);
    System.out.println(arr);
    }

    }


    -----------------------------------------------------------------

    /*

        三、遍历及方法补充

    集合的遍历
    实现思想也是索引思想
    集合的索引从0开始,到size()-1结束
    方法get(int index)

    集合ArrayList方法补充
    add(int 索引,储存的元素) 将元素添加到指定的索引上
    set(int 索引,修改后的元素) 将指定索引的元素,进行修改
    remove(int 索引) 删除指定索引上的元素
    clear() 清空集合中的所有元素
    */
    import java.util.ArrayList;
    public class ArrayListDemo_2{
    public static void main(String[] args){
    ArrayList<Integer> array = new ArrayList<Integer>();
    array.add(121);
    array.add(122);
    array.add(123);
    array.add(124);
    array.add(125);
    array.add(126);

    //将索引2上添加元素7
    array.add(6,127);

    //将索引0上的元素修改成120
    array.set(0,120);

    //将索引4上的元素删除
    array.remove(0);

    //清空集合中的所有元素
    //array.clear();

    //对集合进行遍历
    //使用方法size+get组合进行遍历
    for(int i = 0;i < array.size();i++){
    System.out.println(array.get(i));
    }
    }
    }
    更多相关内容
  • 1. 集合定义什么是集合呢?定义集合是一个存放对象的引用的容器。在Java中,集合位于java.util包下。2. 集合和数组的区别(面试常问)提到容器,就会想起数组,那么集合和数组的区别是什么呢?(这里是重点,面试...

    1. 集合的定义

    什么是集合呢?

    定义:集合是一个存放对象的引用的容器。

    在Java中,集合位于java.util包下。

    2. 集合和数组的区别(面试常问)

    提到容器,就会想起数组,那么集合和数组的区别是什么呢?(这里是重点,面试可能问的比较多)

    数组和集合都是Java中的容器

    数组的长度是固定的,集合的长度是可变的

    数组只能存储相同数据类型的数据,这里的数据类型可以是基本数据类型,也可以是引用类型

    集合可以存储不同数据类型的对象的引用(但一般情况下,我们会使用泛型来约定只使用1种数据类型),但不能存储基本数据类型

    空口无凭,我们来点代码配合理解,首先,我们看下如下的数组代码:

    String[] platformArray = new String[3];

    platformArray[0] = \"博客园\";

    platformArray[1] = \"掘金\";

    platformArray[2] = \"微信公众号\";

    platformArray[3] = \"个人博客\";

    运行代码就会发现,platformArray[3] = \"个人博客\";会引发java.lang.ArrayIndexOutOfBoundsException异常。

    而使用集合时就不存在这个问题,因为集合在声明时不需要指定长度并且长度会根据放入元素的多少而变化:

    List platformList = new ArrayList<>();

    platformList.add(\"博客园\");

    platformList.add(\"掘金\");

    platformList.add(\"微信公众号\");

    platformList.add(\"个人博客\");

    观察上面声明数组的代码,我们可以推断出下面的代码肯定是编译不通过的:

    String[] platformArray = new String[3];

    platformArray[0] = \"博客园\";

    platformArray[1] = \"掘金\";

    platformArray[2] = 1;

    因为数组声明时用的是String类型,而platformArray[2] = 1;赋值时却使用了int类型。

    再来看下下面的集合代码:

    List intList = new ArrayList();

    intList.add(1);

    intList.add(2);

    intList.add(3);

    这段代码也是编译不通过的,在IDEA中,鼠标悬停时会提示如下的错误信息:

    f9cd470da9a7fcb785fcc6cf3e5fdc17.png

    意思是类型参数不能是原始类型(基本数据类型),那怎么使用呢?总不能不让我使用int型的集合吧?

    当然不会,Java为每种基本数据类型都提供了对应的包装类,这里修改为int类型对应的包装类Integer即可:

    List intList = new ArrayList();

    intList.add(1);

    intList.add(2);

    intList.add(3);

    以下为Java的原始类型(基本数据类型)与其对应的包装类:

    原始类型(基本数据类型)

    包装类

    byte

    Byte

    short

    Short

    int

    Integer

    long

    Long

    float

    Float

    double

    Double

    char

    Character

    boolean

    Boolean

    3. 集合的分类

    在Java中,集合主要分为以下3种:

    List集合

    Set集合

    Map集合

    它们之间的继承关系可以参考下图。

    adc606f9b022e890dd219173bac6584c.png

    从上图可以总结出如下几点:

    Java集合的根接口是Collection,它又继承了迭代接口Iterable

    List接口和Set接口继承了Collection接口

    Map接口是独立的接口,并没有继承Collection接口 (这里是重点,面试可能问的比较多)

    List接口常用的实现类有:ArrayList、LinkedList、Vector

    Set接口常用的实现类有:HashSet、LinkedHashSet、TreeSet

    Map接口常用的实现类有:HashMap、HashTable、TreeMap

    4. List集合

    List集合包括List接口以及List接口的所有实现类。List集合具有以下特点:

    集合中的元素允许重复

    集合中的元素是有顺序的,各元素插入的顺序就是各元素的顺序

    集合中的元素可以通过索引来访问或者设置

    List接口常用的实现类有:ArrayList、LinkedList、Vector。

    我们先看下如下示例了解下List集合的用法:

    package collection;

    import java.util.*;

    public class Muster {

    public static void main(String[] args) {

    List strList = new ArrayList<>();

    strList.add(\"a\");

    strList.add(\"b\");

    strList.add(\"c\");

    int i = (int) (Math.random() * strList.size());

    System.out.println(\"随机获取数组中的元素:\" + strList.get(i));

    strList.remove(2);

    System.out.println(\"将索引为2的元素从列表移除后,数组中的元素是:\");

    for (int j = 0; j < strList.size(); j++) {

    System.out.println(strList.get(j));

    }

    }

    }

    以上代码的输出结果为:

    随机获取数组中的元素:a

    将索引为2的元素从列表移除后,数组中的元素是:

    a

    b

    关于List集合的详细用法,ArrayList、LinkedList、Vector的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    5. Set集合

    Set集合包括Set接口以及Set接口的所有实现类。Set集合具有以下特点:

    集合中不包含重复元素(你可以重复添加,但只会保留第1个)

    集合中的元素不一定保证有序

    Set接口常用的实现类有:HashSet、LinkedHashSet、TreeSet。

    我们先看下如下示例了解下Set集合的用法:

    package collection;

    import java.util.*;

    public class Muster {

    public static void main(String[] args) {

    Set platformList = new HashSet<>();

    platformList.add(\"博客园\");

    platformList.add(\"掘金\");

    platformList.add(\"微信公众号\");

    platformList.add(\"个人博客\");

    // 尝试添加重复元素

    platformList.add(\"博客园\");

    platformList.add(\"掘金\");

    for (String platform : platformList) {

    System.out.println(platform);

    }

    }

    }

    以上代码的输出结果为:

    博客园

    个人博客

    掘金

    微信公众号

    可以看出,虽然我们尝试添加了重复元素,但并没有添加成功并且输出的元素没有顺序。

    因此当你的集合中不允许有重复元素并且对排序也没有要求的话,可以使用Set集合。

    关于Set集合的详细用法,HashSet、LinkedHashSet、TreeSet的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    6. Map集合

    Map集合包括Map接口以及Map接口的所有实现类。Map集合具有以下特点:

    Map接口并没有继承Collection接口,提供的是key到value的映射

    Map中不能包含相同的key

    Map接口常用的实现类有:HashMap、HashTable、TreeMap。

    我们先看下如下示例了解下Map集合的用法:

    package collection;

    import java.util.*;

    public class Muster {

    public static void main(String[] args) {

    Map platformMap = new HashMap<>();

    platformMap.put(1, \"博客园\");

    platformMap.put(2, \"掘金\");

    platformMap.put(3, \"微信公众号\");

    platformMap.put(4, \"个人博客\");

    // 尝试添加重复Map

    platformMap.put(4, \"个人博客\");

    // 获取所有的key

    Set keys = platformMap.keySet();

    for (Integer integer : keys) {

    System.out.println(\"Key:\" + integer + \",Value:\" + platformMap.get(integer));

    }

    }

    }

    以上代码的输出结果为:

    Key:1,Value:博客园

    Key:2,Value:掘金

    Key:3,Value:微信公众号

    Key:4,Value:个人博客

    从日志可以看出,当我们尝试重加重复Map时,并没有添加成功。

    关于Map集合的详细用法,HashMap、HashTable、TreeMap的区别(这里是重点,面试可能问的比较多),后续会单独写文总结,敬请期待。

    7. 源码及参考

    8. 最后

    打个小广告,欢迎扫码关注微信公众号:「申城异乡人」,定期分享Java技术干货,让我们一起进步。

    展开全文
  • 主要介绍了Java集合定义与用法,结合实例形式总结分析了Java集合中Set、List和Map相关概念、功能、用法及操作注意事项,需要的朋友可以参考下
  • java中的集合详解

    千次阅读 多人点赞 2020-07-21 15:02:17
    集合集合java中提供的一种容器,可以用来存储多个数据。集合和数组既然都是容器,它们有啥区别呢? 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素,可以存储基本数据类型值。...

                                                 Collection接口和Map接口

    1 Collection集合
    1.1 集合概述

        集合:集合是java中提供的一种容器,可以用来存储多个数据。集合和数组既然都是容器,它们有啥区别呢?

        数组的长度是固定的。集合的长度是可变的。

        数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。

    1.2 集合框架

        Collection:单列集合类的根接口,用于存储一系列符合某种规则的元素,它有两个重要的子接口,分别是java.util.List和java.util.Set。

        List的特点是元素有序、元素可重复。Set的特点是元素无序,而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList,

        Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。

    1.3 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(): 把集合中的元素,存储到数组中。

     

    import java.util.ArrayList;
    import java.util.Collection;
    ​
    public class Demo1Collection {
        public static void main(String[] args) {
            // 创建集合对象
            // 使用多态形式
            Collection<String> coll = new ArrayList<String>();
            // 使用方法
            // 添加功能  boolean  add(String s)
            coll.add("小李广");
            coll.add("扫地僧");
            coll.add("石破天");
            System.out.println(coll);
    ​
            // boolean contains(E e) 判断o是否在集合中存在
            System.out.println("判断  扫地僧 是否在集合中"+coll.contains("扫地僧"));
    ​
            //boolean remove(E e) 删除在集合中的o元素
            System.out.println("删除石破天:"+coll.remove("石破天"));
            System.out.println("操作之后集合中元素:"+coll);
            
            // size() 集合中有几个元素
            System.out.println("集合中有"+coll.size()+"个元素");
    ​
            // Object[] toArray()转换成一个Object数组
            Object[] objects = coll.toArray();
            // 遍历数组
            for (int i = 0; i < objects.length; i++) {
                System.out.println(objects[i]);
            }
    ​
            // void  clear() 清空集合
            coll.clear();
            System.out.println("集合中内容为:"+coll);
            // boolean  isEmpty()  判断是否为空
            System.out.println(coll.isEmpty());     
        }
    }


    2 Iterator迭代器

    2.1 Iterator接口

    JDK专门提供了一个接口java.util.Iterator,遍历集合中的所有元素。

    Iterator接口也是Java集合中的一员,但它与Collection、Map接口有所不同,

    Collection接口与Map接口主要用于存储元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素,因此Iterator对象也被称为迭代器。

    想要遍历Collection集合,那么就要获取该集合迭代器完成迭代操作,获取迭代器的方法:

        public Iterator iterator(): 获取集合对应的迭代器,用来遍历集合中的元素的。

    Iterator接口的常用方法如下:

        public E next():返回迭代的下一个元素。

        public boolean hasNext():如果仍有元素可以迭代,则返回 true。

    接下来我们通过案例学习如何使用Iterator迭代集合中元素:

        注意::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。

    2.2 迭代器的实现原理

    当遍历集合时,首先通过调用t集合的iterator()方法获得迭代器对象,然后使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。

    Iterator迭代器对象在遍历集合时,内部采用指针的方式来跟踪集合中的元素代元素的过程。

    在调用Iterator的next方法之前,迭代器的索引位于第一个元素之前,不指向任何元素,当第一次调用迭代器的next方法后,迭代器的索引会向后移动一位,指向第一个元素并将该元素返回,当再次调用next方法时,迭代器的索引会指向第二个元素并将该元素返回,依此类推,直到hasNext方法返回false,表示到达了集合的末尾,终止对元素的遍历。

    2.3 增强for

    增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。

    格式:

    for(元素的数据类型  变量 : Collection集合or数组){
        //写操作代码
    }

    它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

    //练习1:遍历数组
    public class NBForDemo1 {
        public static void main(String[] args) {
            int[] arr = {3,5,6,87};
            //使用增强for遍历数组
            for(int a : arr){//a代表数组中的每个元素
                System.out.println(a);
            }
        }
    }
    // 练习2:遍历集合
    public class NBFor {
        public static void main(String[] args) {        
            Collection<String> coll = new ArrayList<String>();
            coll.add("小河神");
            coll.add("老河神");
            coll.add("神婆");
            //使用增强for遍历
            for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
                System.out.println(s);
            }
        }
    }

        tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。

    3 泛型

    3.1 泛型概述

    集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。

    泛型:可以在类或方法中预支地使用未知的类型。一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。

    public class GenericDemo {
        public static void main(String[] args) {
            Collection coll = new ArrayList();
            coll.add("abc");
            coll.add("itcast");
            coll.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
            Iterator it = coll.iterator();
            while(it.hasNext()){
                //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
                String str = (String) it.next();
                System.out.println(str.length());
            }
        }
    }

    程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢?

    由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢? Collection虽然可以存储各种对象,但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。

    在JDK5之后,新增了泛型(Generic)语法,在设计API时可以指定类或方法支持泛型,这样在使用API的时候也变得更为简洁,并得到了编译时期的语法检查。


    3.2 使用泛型的好处

        将运行时期的ClassCastException,转移到了编译时期变成了编译失败。

        避免了类型强转的麻烦。

    public class GenericDemo2 {
        public static void main(String[] args) {
            Collection<String> list = new ArrayList<String>();
            list.add("abc");
            list.add("itcast");
            // list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
            // 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
            Iterator<String> it = list.iterator();
            while(it.hasNext()){
                String str = it.next();
                //当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
                System.out.println(str.length());
            }
        }
    }

     tips:泛型是数据类型的一部分,我们将类名与泛型合并一起看做数据类型。

    3.3 泛型的定义与使用

    泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

    (1)在创建对象的时候确定泛型

    例如,ArrayList<String> list = new ArrayList<String>();

    此时,变量E的值就是String类型,那么我们的类型就可以理解为:

    class ArrayList<String>{
         public boolean add(String e){ }

         public String get(int index){  }
         ...
    }

    (2)含有泛型的方法

    定义格式:

    修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

    public class MyGenericMethod {    
        public <MVP> void show(MVP mvp) {
            System.out.println(mvp.getClass());
        }
        
        public <MVP> MVP show2(MVP mvp) {   
            return mvp;
        }
    }

    使用格式:调用方法时,确定泛型的类型
    public class GenericMethodDemo {
        public static void main(String[] args) {
            // 创建对象
            MyGenericMethod mm = new MyGenericMethod();
            // 演示看方法提示
            mm.show("aaa");
            mm.show(123);
            mm.show(12.45);
        }
    }

    (3)含有泛型的接口

    定义格式:

    修饰符 interface接口名<代表泛型的变量> {  }

    public interface MyGenericInterface<E>{
        public abstract void add(E e);
        
        public abstract E getE();  
    }

    3.4 泛型通配符

    当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。
    通配符基本使用:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

    此时只能接受数据,不能往该集合中存储数据。

    public static void main(String[] args) {
        Collection<Intger> list1 = new ArrayList<Integer>();
        getElement(list1);
        Collection<String> list2 = new ArrayList<String>();
        getElement(list2);
    }

    public static void getElement(Collection<?> coll){}
    //?代表可以接收任意类型

        tips:泛型不存在继承关系 Collection<Object> list = new ArrayList<String>();这种是错误的。

    通配符高级使用----受限泛型

    在JAVA的泛型中可以指定一个泛型的上限和下限。

    <1> 泛型的上限:

        格式: 类型名称 <? extends 类 > 对象名称

        意义: 只能接收该类型及其子类

    <2> 泛型的下限:

        格式: 类型名称 <? super 类 > 对象名称

        意义: 只能接收该类型及其父类型

    比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类

    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        
        getElement(list1);
        getElement(list2);//报错
        getElement(list3);
        getElement(list4);//报错
     
        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
     
    }

    // 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}

    4  集合综合案例

    4.1 案例介绍

    按照斗地主的规则,完成洗牌发牌的动作。 具体规则:

    使用54张牌打乱顺序,三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。
    4.2 案例分析

        准备牌:

        牌可以设计为一个ArrayList<String>,每个字符串为一张牌。 每张牌由花色数字两部分组成,我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。 牌由Collections类的shuffle方法进行随机排序。

        发牌

        将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌,剩余牌通过对3取模依次发牌。

        看牌

        直接打印每个集合。

    import java.util.ArrayList;
    import java.util.Collections;
    ​
    public class Poker {
        public static void main(String[] args) {
            /*
            * 1: 准备牌操作
            */
            //1.1 创建牌盒 将来存储牌面的
            ArrayList<String> pokerBox = new ArrayList<String>();
            //1.2 创建花色集合
            ArrayList<String> colors = new ArrayList<String>();
    ​
            //1.3 创建数字集合
            ArrayList<String> numbers = new ArrayList<String>();
    ​
            //1.4 分别给花色 以及 数字集合添加元素
            colors.add("♥");
            colors.add("♦");
            colors.add("♠");
            colors.add("♣");
    ​
            for(int i = 2;i<=10;i++){
                numbers.add(i+"");
            }
            numbers.add("J");
            numbers.add("Q");
            numbers.add("K");
            numbers.add("A");
            //1.5 创造牌  拼接牌操作
            // 拿出每一个花色  然后跟每一个数字 进行结合  存储到牌盒中
            for (String color : colors) {
                //color每一个花色
                //遍历数字集合
                for(String number : numbers){
                    //结合
                    String card = color+number;
                    //存储到牌盒中
                    pokerBox.add(card);
                }
            }
            //1.6大王小王
            pokerBox.add("小☺");
            pokerBox.add("大☠");   
            // System.out.println(pokerBox);
            //洗牌 是不是就是将  牌盒中 牌的索引打乱
            // Collections类  工具类  都是 静态方法
            // shuffer方法   
            /*
             * static void shuffle(List<?> list)
             *     使用默认随机源对指定列表进行置换。
             */
            //2:洗牌
            Collections.shuffle(pokerBox);
            //3 发牌
            //3.1 创建 三个 玩家集合  创建一个底牌集合
            ArrayList<String> player1 = new ArrayList<String>();
            ArrayList<String> player2 = new ArrayList<String>();
            ArrayList<String> player3 = new ArrayList<String>();
            ArrayList<String> dipai = new ArrayList<String>();    
    ​
            //遍历 牌盒  必须知道索引   
            for(int i = 0;i<pokerBox.size();i++){
                //获取 牌面
                String card = pokerBox.get(i);
                //留出三张底牌 存到 底牌集合中
                if(i>=51){//存到底牌集合中
                    dipai.add(card);
                } else {
                    //玩家1   %3  ==0
                    if(i%3==0){
                        player1.add(card);
                    }else if(i%3==1){//玩家2
                        player2.add(card);
                    }else{//玩家3
                        player3.add(card);
                    }
                }
            }
            //看看
            System.out.println("令狐冲:"+player1);
            System.out.println("田伯光:"+player2);
            System.out.println("绿竹翁:"+player3);
            System.out.println("底牌:"+dipai);  
        }
    }


    5 List集合

    5.1  List接口中常用方法

    List作为Collection集合的子接口,不但继承了Collection接口中的全部方法,而且还增加了一些根据元素索引来操作集合的特有方法,如下:

        public void add(int index, E element): 将指定的元素,添加到该集合中的指定位置上。

        public E get(int index):返回集合中指定位置的元素。

        public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

        public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

    5.2 List的子类

    (1) ArrayList集合

    java.util.ArrayList集合数据存储的结构是数组结构。

    元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据、遍历数据,所以ArrayList是最常用的集合。
    (2) LinkedList集合

    java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

    在开发时,LinkedList集合也可以作为堆栈,队列的结构使用。

    实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。了解即可:

        public void addFirst(E e):将指定元素插入此列表的开头。

        public void addLast(E e):将指定元素添加到此列表的结尾。

        public E getFirst():返回此列表的第一个元素。

        public E getLast():返回此列表的最后一个元素。

        public E removeFirst():移除并返回此列表的第一个元素。

        public E removeLast():移除并返回此列表的最后一个元素。

        public E pop():从此列表所表示的堆栈处弹出一个元素。

        public void push(E e):将元素推入此列表所表示的堆栈。

        public boolean isEmpty():如果列表不包含元素,则返回true。

    6 Set接口

    Set集合有多个子类,主要使用java.util.HashSet、java.util.LinkedHashSet这两个集合。

    // Set集合取出元素的方式可以采用:迭代器、增强for。

    // 不能用普通的for循环,因为是无序的,没有U索引/下标。

    6.1 HashSet集合介绍

    java.util.HashSet是Set接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致)。

    java.util.HashSet底层的实现其实是一个java.util.HashMap支持。

    HashSet是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于:hashCode与equals方法。
    6.1.1 HashSet集合存储数据的结构(哈希表)

    在JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。

    而JDK1.8中,哈希表存 储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。

    6.1.2 存储流程图
           往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode和equals方法建立属于当前对象的比较方式。

    6.2  LinkedHashSet

    HashSet保证元素唯一,可是元素存放进去是没有顺序的,那么我们要保证有序,怎么办呢?

    在HashSet下面有一个子类java.util.LinkedHashSet,它是链表和哈希表组合的一个数据存储结构。

    【链表的作用】:记录元素存储时的顺序

    public class LinkedHashSetDemo {
        public static void main(String[] args) {
            Set<String> set = new LinkedHashSet<String>();
            set.add("bbb");
            set.add("aaa");
            set.add("abc");
            set.add("bbc");
            Iterator<String> it = set.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
        }
    }


    结果:
      bbb
      aaa
      abc
      bbc
    6.3 可变参数

    修饰符 返回值类型 方法名(参数类型... 形参名){  }    <=>    修饰符 返回值类型 方法名(参数类型[] 形参名){  }

        注意:如果在方法书写时,这个方法拥有多参数,参数中包含可变参数,可变参数一定要写在参数列表的末尾位置。

    public class ChangeArgs {
        public static void main(String[] args) {
            int[] arr = { 1, 4, 62, 431, 2 };
            int sum = getSum(arr);
            System.out.println(sum);
            //  6  7  2 12 2121
            // 求 这几个元素和 6  7  2 12 2121
            int sum2 = getSum(6, 7, 2, 12, 2121);
            System.out.println(sum2);
        }
    
        /*
         * 完成数组  所有元素的求和 原始写法
         
          public static int getSum(int[] arr){
            int sum = 0;
            for(int a : arr){
                sum += a;
            }
            
            return sum;
          }
        */
        //可变参数写法
        public static int getSum(int... arr) {
            int sum = 0;
            for (int a : arr) {
                sum += a;
            }
            return sum;
        }
    }


    7 Collections
    7.1 常用功能

        java.utils.Collections是集合工具类,用来对集合进行操作。部分方法如下:

        public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。

        public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。

        public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。

        public static <T> void sort(List<T> list,Comparator<? super T> ):将集合中元素按照指定规则排序。

    public class CollectionsDemo {
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            //原来写法
            //list.add(12);
            //list.add(14);
            //list.add(15);
            //list.add(1000);
            //采用工具类 完成 往集合中添加元素  
            Collections.addAll(list, 5, 222, 1,2);
            System.out.println(list);
            //排序方法
            Collections.sort(list);
            System.out.println(list);
        }
    }


    结果:
    [5, 222, 1, 2]
    [1, 2, 5, 222]

    由方法运行结果发现,集合按照顺序进行了排列,可是这样的顺序是采用默认的顺序,如果想要指定顺序该怎么办呢?

    ——>   public static <T> void sort(List<T> list,Comparator<? super T> ):将集合中元素按照指定规则排序。
    7.2 Comparator接口实现

    采用的public static <T> void sort(List<T> list)这个方法完成的排序,实际上要求了被排序的类型需要实现Comparable接口完成比较的功能。

    实现类需要重写compare方法:

    public int compare(String o1, String o2):比较其两个参数的顺序。

        两个对象比较的结果有三种:大于,等于,小于。

        如果要按照升序排序:

        则o1 小于o2,返回(负数);相等返回0;01大于02返回(正数)

        如果要按照降序排序:

        则o1 小于o2返回(正数);相等返回0;01大于02返回(负数)

    public class CollectionsDemo3 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("cba");
            list.add("aba");
            list.add("sba");
            list.add("nba");
            //排序方法  按照第一个单词的降序
            Collections.sort(list, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o2.charAt(0) - o1.charAt(0);
                }
            });
            System.out.println(list);
        }
    }

    //运行结果:
    [sba, nba, cba, aba]


    7.3 Comparable接口实现
    案例:如果要对两个对象进行比较,则需要在对象bean中实现Comparable接口,重写compare方法
     

    //Student 初始类
    
    public class Student{
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = 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;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
        }
    }
    
    public class Demo {
    
        public static void main(String[] args) {
            // 创建四个学生对象 存储到集合中
            ArrayList<Student> list = new ArrayList<Student>();
    
            list.add(new Student("rose",18));
            list.add(new Student("jack",16));
            list.add(new Student("abc",16));
            list.add(new Student("ace",17));
            list.add(new Student("mark",16));
    
    
            /*
              让学生 按照年龄排序 升序
             */
    //        Collections.sort(list);//要求 该list中元素类型  必须实现比较器Comparable接口
    
    
            for (Student student : list) {
                System.out.println(student);
            }
    
    
        }
    }

    发现,当我们调用Collections.sort()方法的时候 程序报错了。

    原因:如果想要对list集合中的元素(Student对象)完成排序,那么必须要实现比较器Comparable接口。

    public class Student implements Comparable<Student>{
        ....
        @Override
        public int compareTo(Student o) {
            return this.age-o.age;//升序
        }
    }

    再次测试,代码就OK 了效果如下:

    Student{name='jack', age=16}
    Student{name='abc', age=16}
    Student{name='mark', age=16}
    Student{name='ace', age=17}
    Student{name='rose', age=18}

    8 Map集合

    8.1 概述

    现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map接口。

        Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。

        Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。

        Collection中的集合称为单列集合,Map中的集合称为双列集合。

        需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。

    8.2 Map常用子类

    常用HashMap集合、LinkedHashMap集合。

        HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

        LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

        tips:Map接口中的集合都有两个泛型变量<K,V>,在使用时,要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同,也可以不同。

    8.3 Map接口中的常用方法

    Map接口中定义了很多方法,常用的如下:

        public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

        public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。

        public V get(Object key) 根据指定的键,在Map集合中获取对应的值。

        boolean containsKey(Object key) 判断集合中是否包含指定的键。

        public Set<K> keySet(): 获取Map集合中所有的键,存储到Set集合中。

        public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
     

    public class MapDemo {
        public static void main(String[] args) {
            //创建 map对象
            HashMap<String, String>  map = new HashMap<String, String>();
    
            //添加元素到集合
            map.put("黄晓明", "杨颖");
            map.put("文章", "马伊琍");
            map.put("邓超", "孙俪");
            System.out.println(map);
    
            //String remove(String key)
            System.out.println(map.remove("邓超"));
            System.out.println(map);
    
            // 想要查看 黄晓明的媳妇 是谁
            System.out.println(map.get("黄晓明"));
            System.out.println(map.get("邓超"));    
        }
    }


    8.4 Map集合遍历键找值方式:keyset()

    键找值方式:即通过元素中的键,获取键所对应的值

    分析步骤:

        获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示:keyset()

        遍历键的Set集合,得到每一个键。

        根据键,获取键所对应的值。方法提示:get(K key)
     

    public class MapDemo01 {
        public static void main(String[] args) {
            //创建Map集合对象
            HashMap<String, String> map = new HashMap<String,String>();
            //添加元素到集合
            map.put("胡歌", "霍建华");
            map.put("郭德纲", "于谦");
            map.put("薛之谦", "大张伟");
    
            //获取所有的键  获取键集
            Set<String> keys = map.keySet();
            // 遍历键集 得到 每一个键
            for (String key : keys) {
                  //key  就是键
                //获取对应值
                String value = map.get(key);
                System.out.println(key+"的CP是:"+value);
            }  
        }
    }

    8.5 Map集合遍历键值对方式

    Map中存放的是两种对象,一种称为key(键),一种称为value(值),它们在在Map中是一一对应关系,这一对对象又称做Map中的一个Entry(项)。

    Entry将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历Map集合时,就可以从每一个键值对(Entry)对象中获取对应的键与对应的值。

    既然Entry表示了一对键和值,那么也同样提供了获取对应键和对应值得方法:

        public K getKey():获取Entry对象中的键。

        public V getValue():获取Entry对象中的值。

    在Map集合中也提供了获取所有Entry对象的方法:

        public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

    键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。

    操作步骤与图解:

            获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示:entrySet()。

            遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。

            通过键值对(Entry)对象,获取Entry对象中的键与值。 方法提示:getkey() getValue()

    public class MapDemo02 {
        public static void main(String[] args) {
            // 创建Map集合对象
            HashMap<String, String> map = new HashMap<String,String>();
            // 添加元素到集合
            map.put("胡歌", "霍建华");
            map.put("郭德纲", "于谦");
            map.put("薛之谦", "大张伟");
    
            // 获取 所有的 entry对象  entrySet
            Set<Entry<String,String>> entrySet = map.entrySet();
    
            // 遍历得到每一个entry对象
            for (Entry<String, String> entry : entrySet) {
                   // 解析
                String key = entry.getKey();
                String value = entry.getValue();  
                System.out.println(key+"的CP是:"+value);
            }
        }
    }


    8.6 HashMap存储自定义类型键值

    练习:每位学生(姓名,年龄)都有自己的家庭住址。那么,既然有对应关系,则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
     

    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = 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;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }
    
    public class HashMapTest {
        public static void main(String[] args) {
            //1,创建Hashmap集合对象。
            Map<Student,String>map = new HashMap<Student,String>();
            //2,添加元素。
            map.put(newStudent("lisi",28), "上海");
            map.put(newStudent("wangwu",22), "北京");
            map.put(newStudent("zhaoliu",24), "成都");
            map.put(newStudent("zhouqi",25), "广州");
            map.put(newStudent("wangwu",22), "南京");
            
            //3,取出元素。键找值方式
            Set<Student>keySet = map.keySet();
            for(Student key: keySet){
                Stringvalue = map.get(key);
                System.out.println(key.toString()+"....."+value);
            }
        }
    }

        当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的hashCode和equals方法(如果忘记,请回顾HashSet存放自定义对象)。

        如果要保证map中存放的key和取出的顺序一致,可以使用java.util.LinkedHashMap集合来存放。

    8.7 LinkedHashMap

    在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构。

    public class LinkedHashMapDemo {
        public static void main(String[] args) {
            LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
            map.put("邓超", "孙俪");
            map.put("李晨", "范冰冰");
            map.put("刘德华", "朱丽倩");
            Set<Entry<String, String>> entrySet = map.entrySet();
            for (Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey() + "  " + entry.getValue());
            }
        }
    }


    8.8 Map集合练习

    需求:

    计算一个字符串中每个字符出现次数。

    分析:

        获取一个字符串对象

        创建一个Map集合,键代表字符,值代表次数。

        遍历字符串得到每个字符。

        判断Map中是否有该键。

        如果没有,第一次出现,存储次数为1;如果有,则说明已经出现过,获取到对应的值进行++,再次存储。

        打印最终结果

    public class MapTest {
    public static void main(String[] args) {
            //友情提示
            System.out.println("请录入一个字符串:");
            String line = new Scanner(System.in).nextLine();
            // 定义 每个字符出现次数的方法
            findChar(line);
        }
        private static void findChar(String line) {
            //1:创建一个集合 存储  字符 以及其出现的次数
            HashMap<Character, Integer> map = new HashMap<Character, Integer>();
            //2:遍历字符串
            for (int i = 0; i < line.length(); i++) {
                char c = line.charAt(i);
                //判断 该字符 是否在键集中
                if (!map.containsKey(c)) {//说明这个字符没有出现过
                    //那就是第一次
                    map.put(c, 1);
                } else {
                    //先获取之前的次数
                    Integer count = map.get(c);
                    //count++;
                    //再次存入  更新
                    map.put(c, ++count);
                }
            }
            System.out.println(map);
        }
    }


    8.9 HashMap排序

    public class SortMap
    {
        public static void main(String[] args)
        {
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("1d", 4);
            map.put("2b", 3);
            map.put("3a", 1);
            map.put("4c", 2);
            System.out.println("原始数据:");
            // 排序前
            for(String s:map.keySet())
            {
                System.out.println(s+":"+map.get(s));
            }
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
            
            // 根据key值排序
            Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
                {
                    return o1.getKey().toString().compareTo(o2.toString());
                }
            });
            System.out.println("根据key值排序:");
            // 根据key值排序后
            for (Entry<String, Integer> entry : list)
            {
                System.out.println(entry.getKey() + ":" + entry.getValue());
            }
            // 根据value排序
            Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2)
                {
                    return o1.getValue()-o2.getValue();
                }
            });
            System.out.println("根据value值排序:");
            // 根据value值排序后
            for (Entry<String, Integer> entry : list)
            {
                System.out.println(entry.getKey() + ":" + entry.getValue());
            }
        }
    }


    9 JDK9对集合添加的优化

    (1)通常,我们在代码中创建一个集合(例如,List 或 Set ),并直接用一些元素填充它。 实例化集合,几个 add方法 调用,使得代码重复。

    public class Demo01 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("abc");
            list.add("def");
            list.add("ghi");
            System.out.println(list);
        }
    }

    (2)Java 9,添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

    需要注意以下两点:

        1:of()方法只是Map,List,Set这三个接口的静态方法,其父类接口和子类实现并没有这类方法,比如 HashSet,ArrayList等待;

        2:返回的集合是不可变的;

    public class HelloJDK9 {  
        public static void main(String[] args) {  
            Set<String> str1=Set.of("a","b","c");  
            //str1.add("c");这里编译的时候不会错,但是执行的时候会报错,因为是不可变的集合  
            System.out.println(str1);  
            Map<String,Integer> str2=Map.of("a",1,"b",2);  
            System.out.println(str2);  
            List<String> str3=List.of("a","b");  
            System.out.println(str3);  
        }  
    }

     

    展开全文
  • java集合类的创建方式

    千次阅读 2020-12-17 14:31:06
    java集合类的创建方式 常常因为不会创建集合类的语法而浪费时间。。 集合可以看作一个容器,集合中的对象可以很容易存放到集合中,也很容易将其从集合中取出来,还可以按一定的顺序摆放。Java中提供了不同的集合类,...

    java集合类的创建方式

    常常因为不会创建集合类的语法而浪费时间。。
    集合可以看作一个容器,集合中的对象可以很容易存放到集合中,也很容易将其从集合中取出来,还可以按一定的顺序摆放。Java中提供了不同的集合类,这些类具有不同的存储对象的方式,并提供了相应的方法方便用户对集合进行遍历。

    集合的长度是可变的,用来存放对象的引用。常见的集合类有List集合、Set集合、Map集合。
      在这里插入图片描述
    下面举一个实例,看看如何创建并添加修改集合元素。

     1 import java.util.Iterator;
     2 import java.util.LinkedList;
     3 import java.util.List;
     4 
     5 public class CollectionDemoList {
     6 
     7     public static void main(String[] args) {
     8         String aString = "A", bString = "B", cString = "C", dString = "D", eString  = "E";
     9         
    10         List<String> list = new LinkedList<>();        // 创建list集合对象
    11         list.add(aString);        // 向集合中添加元素
    12         list.add(bString);
    13         list.add(eString);
    14         // 输出语句,用迭代器
    15         Iterator<String> iter = list.iterator();        // 创建集合迭代器
    16         while(iter.hasNext()) {        // 遍历集合中的元素
    17             System.out.print(iter.next() + " ");
    18         }
    19         
    20         System.out.println();        // 换行
    21         list.set(1, cString);        // 将索引位置1的对象修改为对象bString
    22         Iterator<String> it = list.iterator();
    23         while(it.hasNext()) {
    24             System.out.print(it.next() + " ");
    25         }
    26     }
    27 
    28 }
    

    上述代码中,add()方法用于向集合中添加元素,set()方法用于修改集合中的元素,迭代器用于遍历集合中的元素并输出(会在下面的内容中涉及)。运行结果如下:

    其中创建List集合对象时,“<>”中是集合汇总元素的类型,如上方的String表示集合中的元素由String字符串构成。因为List是一个接口,所以new的是接口的实现类,在Eclipse中光标放在List上按Ctrl+T就可以看见List接口的所有实现类了。
      在这里插入图片描述
    下面看一个例子,用addAll()方法把List集合对象存入到Set集合中并除掉重复值。

    import java.util.ArrayList;
     2 import java.util.HashSet;
     3 import java.util.Iterator;
     4 import java.util.List;
     5 import java.util.Set;
     6 
     7 public class CollectionDemoSet {
     8 
     9     public static void main(String[] args) {
    10         List<String> list = new ArrayList<>();        // 创建List集合对象
    11         list.add("dog");
    12         list.add("cat");
    13         list.add("fish");
    14         list.add("cat");    //重复值
    15         
    16         Set<String> set = new HashSet<>();        // 创建List对象集合
    17         set.addAll(list);        // 将List集合对象添加到Set集合中
    18         Iterator<String> it = set.iterator();
    19         while(it.hasNext()) {
    20             System.out.print(it.next() + " ");
    21         }
    22     }
    23 
    24 }
    

    同理,创建Set对象集合时,Set是一个接口,new的是接口的实现类。运行结果如下:

    由于Set集合中的对象是无序的,遍历Set集合的结果与插入Set集合的顺序并不相同。
      在这里插入图片描述

    import java.util.HashMap;
     2 import java.util.Map;
     3 
     4 public class MapDemo {
     5 
     6     public static void main(String[] args) {
     7         Map<String, String> map = new HashMap<>();        // 创建Map集合
     8         map.put("1", "dog");
     9         map.put("2", "cat");
    10         map.put("3", "fish");
    11         for(int i=1; i<=3; i++) {
    12             System.out.println("第" + i + "个元素是:" + map.get("" + i + ""));
    13         }
    14     }
    15 
    16 }
    

    创建Map集合时,Map接口的“<>”中含有两个类型,分别对应其key与value。
      在这里插入图片描述

    展开全文
  • 关于java基础集合-定义及练习资料
  • Java定义固定大小的列表

    千次阅读 2021-07-16 20:49:36
    Is it possible to define a list with a fixed size that... If not why isn't this available in Java?解决方案Yes,Commons library provides a built-in FixedSizeList which does not support the add, remove a...
  • Java中数组的定义与使用

    千次阅读 2021-09-26 14:46:21
    Java定义数组的语法有两种:    type arrayName[];    type[] arrayName;type 为Java中的任意数据类型,包括基本类型和组合类型,arrayName为数组名,必须是一个合法的标识符,[ ] 指明...
  • java自定义集合

    千次阅读 2017-07-31 21:20:50
    最近在写一些简单的小程序,开始使用集合 类里要用的集合比较多的时候的声明感觉很麻烦(实际上如果有自定义类有放入集合的需求时自定义集合最方便( ̄▽ ̄)/),就准备自己定义集合集合类拿来用。 比如 常规的特定...
  • Java集合排序及java集合类详解[定义].pdf
  • Java Set集合的详解

    万次阅读 多人点赞 2016-07-26 22:39:17
    Set:注重独一无二的性质,该体系集合可以知道某物是否已近存在于集合中,不会存储重复的元素 用于存储无序(存入和取出的顺序不一定相同)元素,值不能重复。 对象的相等性  引用到堆上同一个对象的两个引用是相等的...
  • java集合超详解

    万次阅读 多人点赞 2018-08-03 21:28:15
    一、集合大纲 1.集合和数组的区别: 2.Collection集合的方法: 3.常用集合的分类: Collection 接口的接口 对象的集合(单列集合) ├——-List 接口:元素按进入先后有序保存,可重复 │——...
  • Java创建List的4种方法

    千次阅读 2021-02-12 09:46:46
    1、通过构造方法,例如:List list = new ArrayList<>();然后调用list.add增加元素,如果知道初始...但是这种方法构造出的List是固定长度的,如果调用add方法增加新的元素,会报异常:java.lang.UnsupportedO...
  • Java中的Map集合

    千次阅读 2021-02-26 09:20:37
    特别注意其键值对的键不能是重复的,有想定义有序存取的话,可以使用LinkedHashMap集合。不过定义自定义对象时,要复写其对象的hashCode和equals方法。静态导入的话,不用编辑器的话可以使用下。再定义方法时有多个...
  • Java集合

    万次阅读 2021-05-10 15:38:32
    Java集合 集合框架的概述 1、集合、数组都是对多个数据进行存储操作的结构,简称Java容器 此时的存储主要是指内存层面的存储,不涉及到持久化的存储(.txt,.jpg,数据库中) java集合就像是一种容器,可以动态的把多...
  • 主要介绍了Java集合之HashMap用法,结合实例形式分析了java map集合中HashMap定义、遍历等相关操作技巧,需要的朋友可以参考下
  • java集合之泛型

    千次阅读 2022-03-07 19:46:43
    java泛型是JDK1.5中引入的一个新特性,本质是参数化类型,把类型作为参数传递。 常见的形式由泛型类,泛型方法,泛型接口 语法:<T…>T称为类型占位符,表示一种引用类型。 好处: 提高代码的重用性 防止...
  • java集合中存放集合 收集框架 Collection是Java Collection Framework的顶级接口。 List,Queue和Set是此框架的主要子接口。 集合接口是java.util.package的成员。 Collection接口中有几种方法可用于添加/删除元素...
  • Java如何创建空的集合对象?

    千次阅读 2021-03-22 17:50:32
    有时您需要从Java方法返回一个空集合java.util.Collections实用工具类具有创建空的三个不同的静态常量List,Set和Map。Collections.EMPTY_LISTCollections.EMPTY_SETCollections.EMPTY_MAP当您要创建类型安全的空...
  • java集合的概念

    千次阅读 2017-09-25 09:59:05
    1、java中的集合类:是一种工具类,就像是容器,储存任意数量的具有共同属性的对象 2、集合的作用  a、在类的内部,对数据进行组织  b、简单而快速的搜索大数量的条目  c、有的集合接口,提供了一系列排列有序的...
  • java定义接口的方法

    千次阅读 2021-03-14 02:23:56
    java定义接口的方法发布时间:2020-06-28 13:50:49来源:亿速云阅读:103作者:Leah本篇文章为大家展示了java定义接口的方法,代码简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的详细介绍希望你能有所...
  • java中map集合的用法

    热门讨论 2013-01-07 22:57:06
    而实际上,除了 List 和 Map 都在定义 java.util 中外,两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带的 Map,同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。
  • Java定义Map常量,List常量

    千次阅读 2021-02-12 22:42:22
    一般的方式的使用静态代码块。比如:public final static Map map = new HashMap();static {map.put("key1", ...}下面为一种简单定义Map常量的方式public final static Map NAV_ITEM_ADPTER = new HashMap() {{put...
  • javaList集合的两种赋值方式

    千次阅读 2021-02-05 20:11:19
    List转换 使用BeanUtils工具类 集合转换是不是也想使用copyProperties方法?对你想的没错,想对了一半 只不过要对copyProperties方法进行封装 像这样 /** * @param sources: 数据源类 * @param target: 目标类 * @...
  • Java中大集合

    2012-04-06 20:23:20
    Java集合 HashMap类 IdentityHashMap类的使用 SortedMap类的基本使用 在map中创建自己的类的定义 随机数的集合 等等等等
  • java常用集合集合讲解

    万次阅读 2018-07-04 13:32:59
    一、java集合系列 java集合主要分为List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections )java集合类的关系图 由此图可以看到,主要分为Collection和Map两大类: 1....
  • Java集合的输出

    千次阅读 2020-02-15 11:25:41
    如果要输出 Collection、Set 集合中的内容,可以将其转换为对象数组输出,而使用 List 则可以直接通过 get() 方法输出,但是这都不是集合的标准输出,类集中提供了以下 4 种的输出方式: 文章目录一、迭代输出:...
  • JAVA中的Map集合

    千次阅读 2021-03-26 23:53:05
    JAVA中的Map集合 1.Map简介 java.util.map接口 1.Map称为查找表,该数据结构的样子是一个“多行两列”的表格,左列为key,右列为value,Map总是根据key查找相对的value,存储元素也要求以key-vaule成对存入。 2.常见...
  • java集合构建成树形集合TreeUtil

    千次阅读 2022-03-13 10:09:43
    定义树形结构接口 import java.util.List; /** * 树形结构基础类 * @param <T> */ public interface BaseTree<T> { String getId(); void setId(String id); String getPid(); void setPid...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 631,618
精华内容 252,647
关键字:

java定义集合

java 订阅
友情链接: 113.rar