java——集合的学习（非常全面、快速入门、快速理解）

本篇对java中集合这部分内容进行总结，包括一些常用的方法以及常用的类，例如List中ArrayList。LinkedList；Set中HashSet；以及Queue中ArrayBlockQueue;Map中HashMap和Hashtable；整体而言比较通俗易懂，可以快速掌握这些知识；以下代码可以分篇直接复制到idea中运行；

第一篇

package java_jihe;

import java.util.ArrayList;

//TODO 集合：java集合框架中就包含了对不确定个数的数据处理的集合类；对不确定的有关系的数据进行相同的逻辑处理的场合，使用集合是一个不错的选择
// java中集合分为两大体系：1.单一出现的数据体系；2.成对出现的数据体系，也成为键值对数据，例如身份证号和姓名等（key,value）;
//TODO Collection接口：常用的子接口：
// 1.List：按照插入顺序保存数据，数据是可以重复的；具体的实现类：ArrayList、LinkedList
// 2.Set：集，无序，数据不能重复；具体的实现类：HashSet
// 3.Queue：队列；具体的实现类：ArrayBlockingQueue
//TODO Map接口；具体的实现：
// HashMap,Hashtable;
public class java_30 {
    public static void main(String[] args) {
        //TODO 创建集合对象：索引也是从零开始，底层是一个数组在存数据；
        ArrayList list=new ArrayList();
        //三种方式：
        //1.不需要传递构造参数，直接new就可以,此时底层数组为空数组；
        //2.构造参数需要传递一个int类型的值，用于设定底层数组的长度
        //3.需要传递一个Collection集合类型的值用于将其他集合的数据放置到当前集合中；
        list.add("zhangsan");
        list.add("lisi");
        list.add("tangsan");
        list.add("zhangsan");
        list.add(1);
        //如果集合为空，向里面添加数据时，默认创建长度为10的数组；并且数组中存放的是数据的地址，也就是指向那个数据；并没有将数据直接存放到数组中；
        System.out.println(list);
        //获取集合中数据条数：
        System.out.println(list.size());
        //获取指定位置的数据：
        System.out.println(list.get(1));
        //遍历集合中的数据：
        for(int i=0;i<list.size();i++){
            System.out.println("集合中的数据："+list.get(i));
        }
        System.out.println("-----------");
        //如果不关心集合中数据的位置，可以采用特殊的for循环：
        for(Object obj:list){
            System.out.println("集合中的元素为"+obj);
        }
        //修改数据：set方法：需要传递两个参数，第一个参数是位置，第二个参数是数据；注意这个方法会有一个返回值，返回值就是修改之前的数据；
        Object obj=list.set(1,"wangwu");
        System.out.println("修改前的值"+obj);
        System.out.println(list);
        //删除数据：remove方法；也会有返回值，返回的是删除的数据；
        Object one=list.remove(1);
        System.out.println("删除的数据是"+one);
        System.out.println(list);


    }
}

第二篇：

package java_jihe;

import java.util.ArrayList;

//TODO 集合中常用的方法：
public class java_31 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add("zhangsan");
        list.add("wangwu");
        list.add("zhaoliu");
        System.out.println(list);
        //add方法也可以传递两个参数，第一参数代表位置，第二个参数代表数据，可以进行插入操作：
        list.add(1,"hhh");
        System.out.println(list);

        ArrayList list1=new ArrayList();
        list1.add("111");
        list1.add("222");
        list1.add("123");
        //addAll方法可以将集合添加到另一个集合中
        list.addAll(list1);
        System.out.println(list);
        //判断集合是否为空：isEmpty（）方法：
        System.out.println(list.isEmpty());//false
        //removeAll方法与clear不一样，clear是全都删除，removeAll方法是删除指定集合中的数据，上面添加了list1中的数据，下面进行删除：
        list.removeAll(list1);
        System.out.println(list);
        //清空集合中的数据：clear方法：
        list.clear();
        System.out.println(list);//[]
        System.out.println(list.size());//0
        System.out.println(list.isEmpty());//true

        //判断集合中是否有指定的数据：contains方法，返回boolean类型数据：
        System.out.println(list.contains("zhangsan"));
        //获取指定数据在集合中的第一个位置；只返回第一次出现的；返回索引位置，如果数据不存在返回-1；lastIndexOf()获取最后一次出现的位置，从末尾开始寻找；
        System.out.println(list.indexOf("zhangsan"));
        //复制新集合，clone方法
        Object o=list1.clone();
        ArrayList one=(ArrayList)o;
        System.out.println(one);
        one.add("nihao");
        System.out.println(one);//这两个输出的不一样，说明不是同一个地址，因此是复制出来了一个全新的集合；
        System.out.println(list1);


    }
}

第三篇：

package java_jihe;

import java.util.LinkedList;

//TODO LinkedList的使用：其实是链表结构，有一个first和last，再添加数据后，first和last都指向这个数据；
//TODO LinkedList的常用方法：对于add方法中addFirst和addLast方法是在首位进行增加，然后addAll方法是将另一个集合添加到本集合的后面，与ArrayList一样；
public class java_32 {
    public static void main(String[] args) {
        LinkedList list=new LinkedList();
        list.add("zhangsan");
        list.addFirst("nihao");//代表添加到最前面的位置，first指向这个数据
        System.out.println(list.getFirst());
        System.out.println(list.getLast());//last肯定还是指向zhangsan
        System.out.println(list);
        //此时想将wangwu放在nihao的后面zhangsan的前面：
        list.add(1,"wangwu");
        System.out.println(list);

        //获取数据（遍历数据）：
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("---------------");
        for(Object obj:list){
            System.out.println(obj);
        }
        //修改数据：set方法；
        Object one=list.set(1,"zhangsan");
        System.out.println("被替换的数据是"+one);
        System.out.println(list);
        //删除数据：remove有两种传参方式，第一种传递索引，删除指定索引位置上的元素，返回值是被删除的元素；第二种是传递数据，删除第一次出现的这个数据，返回值是boolean类型，成功是true失败是false；
        Object remove = list.remove(1);
        System.out.println("被删除的数据是"+remove);
        list.set(1,"nihao");
        System.out.println(list);
        System.out.println(list.remove("nihao"));
        System.out.println(list);
    }
}

第四篇：

package java_jihe;
import java.util.ArrayList;
//TODO 泛型：此处只讲为什么使用泛型：
public class java_33 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        Person person=new Person();
        User user=new User();
        list.add(person);
        list.add(user);
        System.out.println(list);
        //由于集合中不限制元素类型，因此当要取一个元素的时候，用一个通用的类进行接收：
        Object obj=list.get(1);//此时应该是user对象，使用了多态，因此obj能使用的方法取决于Object，因为进行了限制，所以obj无法调用User类中的testUser方法；
        //obj.testUser();会报错，所以可以进行强制类型转换
        User one=(User)obj;
        one.testUser();
        //如果将使用remove方法将上面索引为1的数据删除，那么取出来的数据就是Person，上方强制类型转换以及调用User方法等都会出错；所以集合对象在处理不同类型数据时会比较麻烦；

        //所以用到了泛型：这样只能放Person类型的数据；他的子类对象也可以
        ArrayList<Person>list1=new ArrayList<>();
        list1.add(person);
        //list1.add(user);会报错
    }
}
class Person{
    void testpeison(){
        System.out.println("person");
    }
}
class User{
    void testUser(){
        System.out.println("user");
    }
}

第五篇：

package java_jihe;
//TODO 泛型的基本使用：有时也把泛型称之为类型参数；对于类型存在多态的使用，而泛型没有多态的使用；
public class java_34 {
    public static void main(String[] args) {
        Container one=new Container();
        //data可以存放任何数据，因为下方Container类中没有规定data是具体哪一个类型；需要传进来才知道；
        one.data="nihao";
        one.data=new Object();
        Container1<User1> two=new Container1();//注意此处传进去了类型，也就是说下面data只能存放User1类型的数据；
        two.data=new User1();
        //test(two);//这里会报错，本身User1是Object类的子类，按说是可以传进去的，但是对于泛型是没有多态的使用的，因此不能传；
        Container<Object> three=new Container<>();
        test(three);//这样就可以了；
    }
    public static void test(Container<Object> container){
        System.out.println("nihao");
    }
}
//下面相当于定义了一个容器类，此处的C是由创建者传进来
class Container<C>{
    public C data;
}
class Container1<C>{
    public C data;
}
class User1{

}

第六篇：

package java_jihe;

import java.util.ArrayList;
import java.util.Comparator;

//TODO 比较器：
public class java_35 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add(1);
        list.add(3);
        list.add(2);
        System.out.println(list);
        list.sort(new NumberComparator());
        System.out.println(list);
    }
}
class NumberComparator implements Comparator<Integer>{
//对抽象方法进行重写：
    @Override
    public int compare(Integer o1, Integer o2) {
        //TODO 如果第一个数比第二个数大，那么返回结果为正数，表示升序；
        //return o1-o2;
        //TODO 如果第一个数比第二个数小，那么返回结果为负数，表示降序；
        return o2-o1;
        //TODO 如果第一个数和第二个数相等，那么返回0；
        //return 0;
    }
}

第七篇：

package java_jihe;

import java.util.HashSet;

//TODO HashSet的使用：没有索引的概念
public class java_36 {
    public static void main(String[] args) {
        HashSet set=new HashSet();
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");
        System.out.println(set);
        //删除操作：
        set.remove("zhangsan");
        //遍历元素：
        for(Object obj:set){
            System.out.println(obj);
        }
        //和ArrayList方法都差不多
        set.contains("zhangsan");
        set.clear();
        set.clone();
    }
}

第八篇：

package java_jihe;

import java.util.HashSet;

//TODO HashSet
public class java_37 {
    public static void main(String[] args) {
        HashSet set=new HashSet();
        User2 one=new User2();
        one.id=1001;
        one.name="zhangsan";
        User2 two=new User2();
        two.id=1001;
        two.name="zhangsan";
        User2 three=new User2();
        three.id=1002;
        three.name="lisi";
        //上方one和two的name和id都是一样的，three是不一样的；现在将他们三个对象存放到HashSet中：
        set.add(one);
        set.add(two);
        set.add(three);
        System.out.println(set);//可以看到User1和User2都添加到了里面，虽然id和name都一样，但是地址不同,但是一般来说两个对象属性全部一样的话只添加一个就行了，所以此时需要改写hashCode方法和equals方法
        //当重写hashCode和equals方法之后，可以看到User1和User2只添加了一个；
    }
}
class User2{
    public String name;
    public int id;

    @Override
    public int hashCode() {
        return id;//对hashCode进行重写，hash算法是通过hashCode来进行计算的，此时返回id的话，说明两个的hash地址一样，那么存到一个位置，然后进行判断是否是同一个对象，如果是同一个对象那么就舍弃，如果不是同一个对象就用链表链接起来，同存到那个位置；如果想让属性全部相同的两个对象认为是一个对象，那么此时需要改写equals方法；
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof User2){
            User2 user=(User2)obj;
            if(user.id==this.id){
                if(user.name.equals(this.name)){
                    return true;
                }
            }
            return false;
        }
        else{
            return false;
        }
    }
//改写toString方法，那么上方打印输出的不是地址了；
    @Override
    public String toString() {
        return "User["+name+" "+id+"]";
    }
}

第九篇：

package java_jihe;

import java.net.Inet4Address;
import java.util.*;

//TODO HashMap的用法：数据存储是无序的；
public class java_38 {
    public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap();//此处加上泛型，代表只能添加键为String类型value只能添加Integer类型；
        //put可以添加数据，也可以修改数据：
        map.put("zhangsan",3);
        map.put("lisi",2);
        map.put("wangwu",1);
        System.out.println(map);
        //如果再向里面添加一个key一样的，但是value不一样，此时就会将原来的value覆盖掉：，此处其实就是修改数据，会返回被替换掉的value值：
        //put方法就是如果里面没有这个key的话就会添加，如果有的话会将该key对应的value值覆盖；换成新的
        System.out.println("被替换掉的value值："+map.put("zhangsan", 100));
        System.out.println(map);

        //删除数据：remove：
        map.remove("zhangsan");
        map.remove("zhangsan",123);//这个删除是删除特定的键值对的数据，如果不是这样的话就不会删除；
        System.out.println(map);

        //此处还有一个添加数据的方法：
        map.putIfAbsent("nihao",3);
        System.out.println(map);
        map.putIfAbsent("nihao",100);//按理说应该会将原来的value值覆盖掉，但是此处不会覆盖掉，如果之前存在的话就不添加了
        System.out.println(map);
        //真正的修改：replace：如果替换成功返回被替换的value，如果里面没有该key那么返回null；
        System.out.println(map.replace("aaa", 100));
        System.out.println(map);
        //清空集合：
        //map.clear();
        //获取value：用键来获取value：
        System.out.println(map.get("lisi"));
        //获取map集合中所有的key,自动用Set接受，
        Set set=map.keySet();
        System.out.println(set);
        //如果想获取value值，那么可以遍历key来获取value：
        for(Object k:set){
            System.out.println(map.get(k));
        }
        //判断集合中是否有这个键：containsKey:
        System.out.println(map.containsKey("lisi"));
        //获取所有value：
        Collection values=map.values();
        System.out.println(values);
        //获取键值对：
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for(Map.Entry<String,Integer>entry:entries){
            System.out.print(entry+"\t");
            System.out.println(entry.getKey()+"  "+entry.getValue());
        }
        //以下方法都是一样的，跟之前的HaseSet和ArrayList以及LinkedList
        map.size();
        map.isEmpty();
    }
}

第十篇：

package java_jihe;

import java.util.concurrent.ArrayBlockingQueue;

//TODO Queue:队列，先进先出；
public class java_39 {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue queue=new ArrayBlockingQueue(3);//此处需要填写元素个数；
        //add方法不会体现堵塞，上方声明的三个大小，如果add四次的话会直接报错，显示full；

//        queue.put("zhangsan");
//        System.out.println("第一个人挂号");
//        queue.put("lisi");
//        System.out.println("第二个人挂号");
//        queue.put("wangwu");
//        System.out.println("第三个人挂号");
//        queue.put("zhaoliu");//此处发生阻塞，程序运行不停止
//        System.out.println("第四个人挂号");
        //还有一个方法，offer，返回boolean类型的值，添加成功返回true失败返回false；
        boolean one=queue.offer("zhangsan");
        boolean two=queue.offer("wangwu");
        boolean three=queue.offer("zhaoliu");
        System.out.println(one+" "+two+" "+three);
        boolean four=queue.offer("nihao");
        System.out.println(four);
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue.poll());//当队列为空的时候，再弹出会返回null；
    }
}

第十一篇：

package java_jihe;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

//TODO 迭代器：
public class java_40 {
    public static void main(String[] args) {
        HashMap<String,Integer>map=new HashMap<>();
        map.put("zhangsan",1);
        map.put("lisi",2);
        map.put("wangwu",3);
        Set<String> key = map.keySet();

        Iterator<String> iterator=key.iterator();
        while(iterator.hasNext()){
            String k=iterator.next();
            if("wangwu".equals(k)){
                iterator.remove();//此处已经迭代到了第三个元素，因此不需要写索引或者具体哪个元素，可以对当前元素进行删除；
            }
            System.out.println(map.get(k));

        }


    }
}