Java计算集合相加的总之 java集合减法

转载

mob64ca13f96cda 2023-08-26 07:49:14

文章标签 Java计算集合相加的总之 java System List ide 文章分类 Java 后端开发

文章目录

集合

Collection集合

List集合

ArrayList
LinkedList

Set集合

HashSet
TreeSet

Map集合

HashMap

迭代器

Iterator
ListIterator

foreach

Properties
小贴士

集合

Collection集合

add()方法用于添加元素 get()方法，用于获取某一下标处的元素 isEmpty()方法返回布尔类型，集合是否为空 size()方法，返回集合的长度 contains()方法，判断集合中是否包含该元素 containsAll()方法，判断某一集合是否包含另一集合的所有元素 remove()方法用于移除元素 removeAll()，移除一个集合中包含另一个集合的所有元素 indexOf()方法，返回某一元素首次出现的下标 lastIndexOf()方法，返回某一元素最后一次出现的下标 equals()方法，用于判断两集合中元素是否相同 subList()方法，用于截取部分元素，得到新集合 LinkedList中特有方法：addFirst()方法，添加元素到首位 addLast()方法，添加元素到末位 getFirst()方法，获取首位元素 getLast()，获取末位元素 removeFirst()，移除首位元素 removeLast()，移除末位元素

public static void main(String[] args) {
	//创建Collection对象
	Collection<String> c1=new ArrayList();//ArrayList()底层封装的是数组
	//集合中添加指定元素
    c1.add("路飞");
    c1.add("索隆");
    c1.add("娜美");
    c1.add("山治");
    System.out.println(c1);
    //移除集合中指定元素，返回布尔类型
    System.out.println(c1.remove("山治"));//true
    System.out.println(c1.remove("乌索普"));//false
    //判断集合是否为空，获取集合元素个数
    System.out.println(c1.isEmpty());//false
    System.out.println(c1.size());//3
    //判段是否包含指定元素
    System.out.println(c1.contains("娜美"));//true
    System.out.println(c1.contains(""));//false
    //c1.clear();//清空元素
    System.out.println(c1);//[]       
    }

List集合

public static void main(String[] args) {
    //List是Collection接口的子接口，是一个有序的集合
    //创建List的对象
    List<String> list=new ArrayList();
    list.add("罗宾");
    list.add("乌索普");
    list.add("弗兰奇");
    list.add("布鲁克");
    //往指定位置添加元素
    list.add(0,"乔巴");
    list.add(2,"乔巴");
    list.add("乔巴");//不指定位置，则添加在最后
    System.out.println(list);
    //获取指定下标处的元素
    System.out.println(list.get(0));
    System.out.println(list.get(2));
    //删除指定下标出的元素，并返回该元素
    System.out.println(list.remove(0));//乔巴
    System.out.println(list);
    

    System.out.println(list.indexOf("乔巴"));//2
    System.out.println(list.lastIndexOf("乔巴"));//5
    System.out.println(list.lastIndexOf("托尼托尼·乔巴"));//-1，不存在
    System.out.println(list);
    //获取集合中部分元素组成的新的集合
   List<String> list1=list.subList(1,5);//[1,5)
    System.out.println(list1);//[乌索普，乔巴，弗兰奇，布鲁克]
    
    //测试集合与集合之间的关系
    Collection<String> c2=new ArrayList();
    c2.add("罗宾");
    c2.add("甚平");
    System.out.println("c2="+c2);//c2=[罗宾，甚平]
    //判断当前集合是否包含另一个集合中的所有元素
    System.out.println("c1是否包含c2:"+c1.containsAll(c2));//c1是否包含c2:false
    
    Collection<String> c3=new ArrayList();
    //将另一个集合中的所有元素添加到当前集合中
    c3.addAll(c2);
    System.out.println(c3);//[罗宾，甚平]
    //判段两个集合中的元素是否相同
    System.out.println(c3.equals(c2));//true
    
}

ArrayList

public class ArrayListDemo {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> list=new ArrayList();
        //创建学生对象
        Role r1=new Role("Luffy",19,"风车村");
        Role r2=new Role("Zoro",21,"霜月村");
        Role r3=new Role("Nami",20,"可可亚西村");
        Role r4=new Role("Usopp",19,"西罗普村");
        //往集合添加元素
        list.add(r1);
        list.add(r2);
        list.add(r3);
        list.add(r4);
        //使用for循环遍历集合
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));//获取指定下标的元素
        }
    }
}
class Role{
    private String name;
    private int age;
    private  String address;

    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;

    }
    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

LinkedList

在存储元素前，它会先创建一个节点对象，一个节点对象包括：前引用元素后引用。前引用指向前一个节点的后引用，第一个节点的前引用为null 后引用指向后一个节点的前引用，最后一个节点的后引用为null

public static void main(String[] args) {
    //创建LinkedList的对象实例
    LinkedList<String> list=new LinkedList();
    list.add("前进梅利号");
    list.add("飞天梅利号");
    list.add("万里阳光号");
    System.out.println(list);
    System.out.println("--------------(❁´◡`❁)----------------");
    //测试特有方法
    list.addFirst("出发");
    list.addLast("嘻");
    System.out.println(list);//[出发,前进梅利号,飞天梅利号,万里阳光号,嘻]
    System.out.println("--------------(❁´◡`❁)----------------");
    System.out.println(list.getFirst());//出发
    System.out.println(list.getLast());//嘻
    System.out.println("--------------(❁´◡`❁)----------------");
    System.out.println(list.removeFirst());
    System.out.println(list.removeLast());
    System.out.println(list);//[前进梅利号,飞天梅利号,万里阳光号]
    System.out.println("--------------(❁´◡`❁)----------------");
    for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));//获取指定下标的元素
    }
}

Set集合

set不包含重复元素，特点：没有下标，不能通过索引获取元素，元素是无序的，（存入和取出顺序可能不同）元素不可以重复（包括null） set接口继承父类接口Collection的方法引用

HashSet

HashSet实现了Set接口，不允许重复元素，允许元素值为null，且只有一个，不保证元素顺序扩充容量，当内容占据0.75倍的内存时，就会扩充内存为前内存的2倍 HashSet(int , float),元素，指定占据多少时扩充

public static void main(String[] args) {
    //创建HashSet对象
    Set<String> hs1=new HashSet();
    //添加元素
    boolean b1=hs1.add("香克斯");
    hs1.add("路飞");
    hs1.add("巴基");
    boolean b2=hs1.add("巴基");
    System.out.println(hs1);//[香克斯, 路飞, 巴基]
    System.out.println("b1："+b1);//b1：true
    System.out.println("b2："+b2);//b2：false
    System.out.println("--------------(❁´◡`❁)----------------");

    //测试是否为空，是否包含指定元素,集合大小
    System.out.println(hs1.isEmpty());//false
    System.out.println(hs1.contains("路飞"));//true
    System.out.println(hs1.size());//3
    System.out.println("--------------(❁´◡`❁)----------------");

    //测试删除指定元素
    System.out.println(hs1.remove("巴基"));//true
    System.out.println(hs1.remove("巴基"));//false
    System.out.println(hs1);//[香克斯，路飞]
    System.out.println("--------------(❁´◡`❁)----------------");

    HashSet<String> hs2=new HashSet<>();
    hs2.add("乔拉可尔·米霍克");
    hs2.add("巴索罗米·熊");
    hs2.add("波雅·汉库克");
    HashSet<String> hs3=new HashSet<>();
    hs3.add(" 波雅·汉库克 ");
    hs3.add("卡普");
    hs3.add("战国");
    System.out.println(hs2);//[乔拉可尔·米霍克,巴索罗米·熊,波雅·汉库克]
    System.out.println(hs3);//[波雅·汉库克,卡普,战国]
    System.out.println(hs2.containsAll(hs3));//false,hs2没有包含hs3的所有元素
    System.out.println("--------------(❁´◡`❁)----------------");

    System.out.println(hs2.removeAll(hs3));//true,删除hs2包含hs3中的元素
    System.out.println(hs2);//[乔拉可尔·米霍克,巴索罗米·熊]
    System.out.println(hs3);//[波雅·汉库克,卡普,战国]

    //for循环遍历集合
    for (int i = 0; i <hs3.size() ; i++) {
        System.out.println(hs3.get(i));//获取指定下标的元素
    }
}

public static void main(String[] args) {
    HashSet<String> s=new HashSet<>();
    s.add(new String("龙"));
    s.add(new String("卡普"));
    s.add(new String("龙"));
    //重写了HashCode（）（根据内容生成Hash值，内容相同，Hash值相同)
    //重写了equals（）（根据内容比较，内容相同，比较结果也相同）
        System.out.println(s);//[龙，卡普]
    }

//去重案例
public class AnLi {
    public static void main(String[] args) {
        HashSet<Role> s=new HashSet<>();
        Role s1=new Role("tom",19,"天津");
        Role s2=new Role("tom",19,"天津");
        Role s3=new Role("jack",20,"北京");
        Role s4=new Role("jack",20,"北京");
        s.add(s1);
        s.add(s2);
        s.add(s3);
        s.add(s4);
        //当重写HashCode（）和equals（）方法就会去重
        System.out.println(s);
    }
}
class Role{
    private String name;
    private String position;

    public Role(String name,String address) {
        this.name = name;
        this.position=position;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position=position;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Role role = (Role) o;
        return name.equals(role.name) &&
                position.equals(role.position);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, position);
    }

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", position='" + position + '\'' +
                '}';
    }
}

TreeSet

特点：不包含重复元素没有索引可以将元素按照规则进行排序空参构造，类实现comparable，重写comparator() 有参构造使用比较器排序，让集合构造重写compareto（）

//TreeSet空参
public class TreeSetDemo {
    public static void main(String[] args) {
       /* 
        TreeSet<Integer> s = new TreeSet<>();
        s.add(2);
        s.add(1);
        s.add(5);
        s.add(6);
        s.add(8);
        System.out.println(s);//[1, 2, 5, 6, 8],将元素进行了排序*/

        TreeSet<Student> ts = new TreeSet<>();//空参构造
        Student s1=new Student("艾斯",22);
        Student s2=new Student("萨博",22);
        Student s3=new Student("路飞",19);
        /*
        首先空参构造，
        类实现comparable
        重写comparator方法,后者调用该方法，this就指后者，如果返回值为负数，后者存到左边，
                  先存入s1，再存s2，s2为后者          如果是正数，后者存到右边，
                  存s3先和s1比，大则继续往后比         如果是0，表示重复，不存
         */
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        System.out.println(ts);
        //[Student{name='路飞', age=19}, Student{name='艾斯', age=22}, Student{name='萨博', age=22}]
        //底层将中文转成拼音，在进行排序，如果拼音相同，那么程序认为重复

    }
}
class Student implements Comparable<Student>{
    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {
      /*  //按照年龄进行排序
        //只要年龄相同就会认为是重复，其他参数就不考虑
       int i= this.age-o.age;
       return i;*/
        //此方法内，年龄为主判断方法，姓名为次要判断条件
        int i= this.age-o.age;
        //String类中有CompareTo（）方法
        i = i==0 ? this.name.compareTo(o.getName()) : i;
        return i;
    }

    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 +
                '}';
    }
}

//TreeSet有参
public class TreeSet1 {
    public static void main(String[] args) {
        TreeSet<Role> s=new TreeSet<>(new Comparator<Role>() {
            @Override
            public int compare(Role o1, Role o2) {
                //o1表示要存入的元素，o2表示已经存入集合的元素
                int result=o1.getAge()-o2.getAge();//判断的主要条件
                result= result==0?o1.getName().compareTo(o2.getName()):result;//判断的次要条件
                return result;
            }
        });
        Role t1=new Role("黄猿",58);
        Role t2=new Role("赤犬",55);
        Role t3=new Role("青雉",49);
        s.add(t1);
        s.add(t2);
        s.add(t3);
        System.out.println(s);
    }
}
class Role{
    private String name;
    private int age;

    public Role() {
    }

    public Role(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 "Role{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Map集合

Map为双列集合，每组元素都包括[key，value]，为任意类型特点：key不允许重复，再添加第二次已有的key时，value会被覆盖通过key获取value，key和value一对一元素是无序的遍历Map需要先将其转成EntrySet，再进行遍历方法： put()方法，用于添加元素 get()方法，用于获取元素 remove()方法，用于移除元素 size()方法，获取集合的长度 isEmpty()方法，返回布尔型，判断集合是否为空 containsKey()方法，判断是否包含某个Key containsValue()方法，判断是否包含某个Value keySet()方法，获取集合中所有key组成的set集合 values()方法，获取集合中所有value组成的Collection集合 entrySet()方法，获取集合中[key-value]组成的set集合

HashMap

HashMap是Map接口的实现，底层是一个Entry数组

public static void main(String[] args) {
        //创建Map对象实例
        Map/*<String,String>*/ map=new HashMap<>() ;
        map.put("1",1);
        map.put("2",2);
        System.out.println(map);
        //指定泛型
        Map<String,String> map1=new HashMap<>() ;
        map1.put("罗宾","娜美");
        map1.put("索隆","山治");
        System.out.println(map1);
        System.out.println(map1.get("索隆"));//山治
        System.out.println(map1.remove("罗"));//null
        System.out.println(map1);//{罗宾=娜美, 索隆=山治}
        System.out.println(map1.size());//2
        System.out.println(map1.isEmpty());//false
        //判断集合中是否包含指定的key，指定的value
        System.out.println(map1.containsKey("索隆"));//true
        System.out.println(map1.containsValue("山治"));//true
        //获取Map集合中所有key组成的set集合
        System.out.println(map1.keySet());//[罗宾, 索隆]
        //获取Map集合中所有的value组成的Collection集合
        System.out.println(map1.values());
        //返回Map集合中key-value对儿组成的set集合
        //生成一个set集合泛型是map.entry
        Set<Map.Entry<String,String>> entires=map1.entrySet();
        System.out.println(map1.entrySet());//[罗宾=娜美, 索隆=山治]
        for (Map.Entry<String,String> m:entires) {
            System.out.println(m);
        }
        //生成set集合泛型为map.entry
        Iterator<Map.Entry<String, String>> iterator = entires.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

/*遍历Map的方法：
    keySet（）
    Collection values（）
    Set EntrySet（）
    */
public static void main(String[] args) {
        Map<String,String> map=new HashMap<>() ;
        map.put("罗宾","娜美");
        map.put("索隆","山治");

        Set<String> set= map.keySet();
        for (String key:set) {
            System.out.println(key+""+map.get(key));
        }

        Collection<String> value=map.values();
        for (String v:value) {
            System.out.println(v);
        }

        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> e:entrySet) {
            System.out.println(e.getKey()+e.getValue());
        }
    }

迭代器

Iterator

迭代器主要用于遍历，且依赖于集合存在迭代器创建后，指针指向第一个元素上方调用hasNext()方法，判断指针下方是否有元素，有则返回true 调用Next()方法，将指针下移一位，并获取当前指针指向的元素

public static void main(String[] args) {
        //创建List的对象
        List<String> list=new ArrayList();
        list.add("我");
        list.add("是");
        list.add("甜");
        list.add("崽");
        //使用Iterator()方法获取迭代器遍历集合,Collection集合都可以使用这个迭代器
        Iterator<String> iterator=list.iterator();//获取迭代器
        while(iterator.hasNext()){//判断指针下方是否有元素，
            System.out.println(iterator.next());// 指针向下移动一位，打印元素
        }
    }

ListIterator

ListIterator继承了Iterator 迭代器创建后，指针指向第一个元素上方调用hasNext()方法，判断指针下方是否有元素，有则返回true 调用Next()方法，将指针下移一位，在获取当前指针指向的元素 previous()方法返回列表中的上一个元素 hasPrevoius()方法如果在相反方向迭代具有更多元素，则返回true

public static void main(String[] args) {
        //创建List的对象
        List<String> list=new ArrayList();
        list.add("我");
        list.add("是");
        list.add("甜");
        list.add("崽");
        //使用Iterator()方法获取迭代器遍历集合,Collection集合都可以使用这个迭代器
       ListIterator<String> listiterator=list.listIterator();
        while(listiterator.hasNext()){
            System.out.println(listiterator.next());
        }
         //反向遍历list集合（先正向遍历，在反向遍历）
        while(listiterator.hasPrevious()){
            System.out.println(listiterator.previous());
        }
    }

foreach

格式：for (数组数据类型或者泛型变量名:数组名或者集合名) { } foreach：增强for循环，简易迭代器底层为迭代器与普通for循环的区别：无法获取下标，不可以修改数组或集合中元素当普通for循环修改元素时，修改的是堆内存当中的值

public static void main(String[] args) {
        //创建List的对象
        List<String> list=new ArrayList();
        list.add("我");
        list.add("是");
        list.add("甜");
        list.add("崽");
      for (String l:list) {
            System.out.println(l);
        }
        //使用普通for循环
      for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));//获取指定下标的元素
        }
    }

Properties

当于Hashtable 是一个Map体系的集合跟IO相关的方法没有泛型，不需要尖括号只存字符串

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Map<String,String> map=new Hashtable();
        map.put("1","list");
        System.out.println(map.get("1"));

        Properties pro=new Properties();
        //增加元素
        pro.put("name","luffy");
        pro.put("age","19");
        System.out.println(pro);//{age=19, name=luffy}
        //删除元素
        //pro.remove("age");
        //System.out.println(pro);//{name=luffy}
        //修改元素
        pro.put("age","20");//键不存在为添加，键存在为覆盖
        System.out.println(pro);//{age=20, name=luffy}
        //查询元素
        System.out.println(pro.get("name"));

        //遍历
        Set<Object> ob = pro.keySet();
        for (Object key:ob) {
            System.out.println(key+":"+pro.get(key));
        }
        System.out.println("------");
            //所有键值对组成的对象
        Set<Map.Entry<Object, Object>> entries = pro.entrySet();
        for (Map.Entry<Object, Object> key:entries
             ) {
            //Object value;
            System.out.println(key);
        }

        //方法(key,value)键和值必须是String类型
        Properties pro1=new Properties();
        pro1.setProperty("路飞","风车村");
        pro1.setProperty("娜美","可可西亚村");
        System.out.println(pro1);
        System.out.println(pro1.getProperty("路飞"));
        System.out.println(pro1.stringPropertyNames());

        //IO
        //load()：将指定文件中的键值对数据读取到Properties集合中
        Properties pro2=new Properties();
        FileReader fr=new FileReader("a.properties");
        //调用load()方法完毕后，文件的数据就已经在pro集合中了
        pro2.load(fr);
        fr.close();
        System.out.println(pro2);//Map为无序的，所以可能和文件中的顺序不同

        //Store()：将集合中的数据以键值对的形式保存到指定文件中
        pro2.setProperty("db1","123");
        pro2.setProperty("db2","1231");
        pro2.put("db3","12345");
        FileWriter fw=new FileWriter("a.properties");
        pro2.store(fw,null);//第二个参数为注释
        fw.close();
    }
}