Java学习记录｜集合类

集合：就是一个容器，放置数据，一般一个集合中放同一类型的数据
集合类中也有很多方法，使用中再熟练即可
集合类的有序性：
添加元素会按照添加的顺序排列；
集合里面的数据可以重复

1. ArrayList

get(index)：获得指定索引的数据
add(object)：添加一条数据
add(index,element): 插入，在指定位置添加数据

public static void main(String[] args) {
        ArrayList al=new ArrayList();//集合类对象
        al.add("小明");//集合里面数据的添加
        al.add("小华");
        al.add("小林");
        System.out.println(al.get(0));//集合数据的访问，提供索引即可
    }//返回小明

addall(collection)：添加多条数据

在上面代码基础上

        ArrayList al2=new ArrayList();//集合类对象
        al2.addAll(al);
        System.out.println(al2);

输出

[小明, 小华, 小林]

遍历数据，添加for循环

法1: get方法和size方法

	  for(int i=0;i<al.size();i++){
            System.out.print(al.get(i)+" ");
        }

法2: 引入遍历器Iterator中的next方法,遍历数据，但只能遍历一次

在这里插入图片描述

        Iterator iterator=al.iterator();
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());
        System.out.println(iterator.next());

因为next()方法调用有限次数，如果下一个为空则报错，所以加入while循环

        Iterator iterator=al.iterator();

        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

法3:增强版的for循环

	  for(Object o:al){//默认Object类型，o为临时变量
           System.out.println(o);
       }

也可以在数组中使用该方法

       int[] array=new int[]{1,2,3,4,5};
       int result=0;
       for(int temp:array){
           result+=temp;
       }
        System.out.print(result);//输出15

remove(index)和remove(element) 删除指定位置或指定数据

         al.remove("小明");
         al.remove(0);

isEmpty() 判断是否为空
contains() 判断是否包含
toArray() 转变成数组，返回的是object类的数组，就可以用数组中的方法进行遍历，取得所有的元素

		Object[] ob=al.toArray();//转变成数组之后接下来遍历
        for(int i=0;i<ob.length;i++){
            System.out.print(ob[i]+" ");
        }

但当对其中的元素进行操作时，get获得的是Object类型，所以进行其他操作时需要转变类型
tips：
ArrayList中的所有对象是Object类型，如果要使用的话，要转变成对应的类型

public static void main(String[] args) {
        ArrayList al=new ArrayList();//每一个对象都是object类型
        al.add(1);
        al.add(2);
        al.add(3);
        al.add(555);

        int result=0;
        for(int i=0;i<al.size();i++){
            //result+=al.get(i);错误，get(object)，需要转变类型，才能进行其他操作
            result+=(int)al.get(i);//添加的是int类型，所以转换也是int类型
        }
        System.out.println(result);
    }

2. Vector

使用方法同ArrayList
比如遍历数据

public static void main(String[] args) {
        Vector v=new Vector();
        v.add("lina");
        v.add("jack");
        v.addElement(1);
        for(Object o:v){
            System.out.println(o);
        }

和ArrayList区别：
Vector线程较为安全，但性能较低

3. LinkedList

使用方法同ArrayList

比如遍历数据

public static void main(String[] args) {
        LinkedList ll=new LinkedList();
        ll.add(234);
        ll.add(11);

        for(Object o:ll){
            System.out.println(o);
        }
    }

新方法：首位添加数据

    	ll.addFirst(1);
        ll.addLast(34);

和ArrayList区别

ArrayList内部使用数组进行存储，插入删除数据较慢
LinkedList内部使用链表进行存储，可以方便插入删除数据

Q：集合中泛型怎么使用？

问题：
求和时，每次都需要强制类型转换，很繁琐，如何直接取出int类型数据？

 public static void main(String[] args) {
        ArrayList al=new ArrayList();

        al.add(123);
        al.add(344);
        al.add(12);
        al.add(5);

        int result=0;
        for(Object o:al){
            result+=(int)o;//ArrayList存储的是Object类型，所以需要强制类型转换
        }
        System.out.print(result);
    }

解决：
泛型的使用
tips：集合里面只能存储引用类型，存储整型时，会自动对基本类型进行装箱操作，即把基本类型包装成Interger对象；而在数组中，可以存储基本类型和引用类型

public static void main(String[] args) {
        ArrayList<Integer> al=new ArrayList<Integer>();//这个集合里面只能存储int类型，声明整型集合
        al.add(123);//封装成一个Integer对象
        al.add(344);
        al.add(12);
        al.add(5);

        int result=0;
        for(int o:al){//同样声明int类型，不用强制类型转换
            result+=o;
        }
        System.out.print(result);
    }

类似Vector

Vector<String> v=new Vector<String>();
        v.add("wwww");

4. HashSet

for循环遍历

 public static void main(String[] args) {
        HashSet hs=new HashSet();
        hs.add(1);
        hs.add(2);
        hs.add(3);
        for(Object o:hs){
            System.out.print(o);
        }
    }

5. TreeSet

和其他集合的区别：
ArrayList LinkedList Vector 可添加重复数据，有序
HashSet TreeSet 不可添加重复数据，会自动去重，无序，所以无法通过索引获取某数据，没有get方法

Q：集中中如何存储自定义的类？

以ArrayList存放自定义的类为例

(Student类的setter和getter方法，Student构造方法已给出）

public static void main(String[] args) {
        ArrayList<Student> al=new ArrayList<Student>();//只能存放Student类

        Student s=new Student("lina", "1", "reading");
        al.add(s);//添加一个自定义类的对象
        al.add(new Student("wang", "2", "sleeping"));

        for(Student temp:al){
            System.out.print(temp.getId()+" "+temp.getName()+" "+temp.getHobby());
        }
    }

输出

1 lina reading2 wang sleeping

6：HashMap

put方法

无add方法，替代之put方法
以键值对的形式存储 key-value
取值时通过键key来取值，key不能重复（如果相同的key，会把之前的value覆盖）

  public static void main(String[] args) {
        HashMap mp=new HashMap();
        mp.put(1, "lina");
        mp.put(2, "mike");
        mp.put(3, "jack");

        System.out.println(mp.get(1));
        System.out.println(mp.get(2));
        System.out.println(mp.get(3));
    }

输出值value，可以重复

lina
mike
jack

遍历

遍历键，返回键的集合（类似set集合）

 for(Object key:mp.keySet()){
            System.out.print(key+" "+mp.get(key));
        }

遍历值，返回值的集合
values()，内为collection类型，所以可重复

 for(Object value:mp.values()){
            System.out.println(value);
        }

判断

containsKey()
containsValue()
判断是否有某个键或值返回布尔类型

7：TreeMap

和HashMap使用方法一样，存储上不一样
可指定泛型，比如

 TreeMap<Integer,String> tm=new TreeMap<Integer,String>();

8：Hashtable

使用起来和和HashMap几乎一样

9：总结

集合类

Collection：存储单个值
数据有序可以重复（List）：ArrayList，LinkedList，Vector
ArrayList和LinkedList区别在于：ArrayList使用数组进行存储；LinkedList使用链表进行存储，方便进行数据的插入删除。
Vector和ArrayList区别在于Vector线程安全，性能较低；ArrayList线程不安全，但性能较高。
数据无序不可重复（Set）：HashSet，TreeSet
Map：存储键值对
HashMap，TreeMap，Hashtable
HashMap和TreeMap的区别在于存储的结构不一样
HashMap和Hashtable区别在于线程的安全性

学习来源：【bilibili：siki学院】

来源：CSDN

作者：nanali_lili

链接：https://blog.csdn.net/linanali0606/article/details/104679042

标签

arraylist