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

发布时间:2023年12月28日

本篇对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));

        }


    }
}

文章来源:https://blog.csdn.net/m0_57957187/article/details/135253813
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。