集合的总结

1.集合概述

集合：能装对象的对象

1.List  线性结构，可变长度。

2.Set 集合，非线性，去除重复。

3.Map 映射，储存的时候以key.value的形式储存数据，名字;电话

在Java中所有的集合的根：collection接口

2.List集合

ArrayList------列表
LinkedList----链表
列表可以存放重复的数据，按照我们存储的顺序进行存储
链表是一种物理存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

对于程序员来说，都是一样的，使用最多的是ArrayList。查询效率高

对List有哪些常用的操作
1.add（）添加元素
2.remove（）删除元素
3.get（）列表中获取到某个元素
4.size（）列表的大小（列表中装了多少个元素）
5.contains（）判断列表中是否有xxx东西
遍历列表
for（int i = 0；i<arr.length;i++）{
sout(arr[i])
}

package Gather;
import java.util.ArrayList;
import java.util.List;
public class TestList {
    public static void main(String[] args) {
        List list = new ArrayList();
//        //add（）添加元素
//        list.add("打野");
//        list.add("上路");
//        list.add("中路");
//        list.add("下路");
//        list.add("辅助");
//        System.out.println(list);
//        //remove（）删除元素
//        list.remove("打野");
//        System.out.println(list);
//        //size（）从列表的大小（列表中装了多少个元素）
//        System.out.println(list.size());
//        //get（）从列表中获取到某个元素
//        Object obj = list.get(1);//列表的下标也是从0开始的
//        String s = (String) obj;
//        System.out.println(s);
//        //判断列表中是否有xxx东西
//        System.out.println(list.contains("三路"));



        //遍历列表
        for (int i = 0; i<list.size();i++){
            String s = (String) list.get(i);//向下转型，强转
            System.out.println(s);
        }
    }
}

3._Set集合

HashSet

无序，乱的，不重复
TreeSet
默认进行排序，不重复

Set的操作：
1.add（）添加元素
2.remove（）删除元素
3.size（）列表的大小（列表中装了多少个元素）
4.countains（）是否包含xxx

package Gather;

import java.util.HashSet;
import java.util.Set;

public class TestSet {
    public static void main(String[] args) {
        Set s = new HashSet();
        s.add("DNF");
        s.add("LOL");
        s.add("CS");

        //s.add("LOL");//重复的数据添加不进去
        System.out.println(s.size());

        s.remove("LOL");
        System.out.println(s);

        System.out.println(s.contains("CS"));
    }

}

4.Map集合

名字————>电话
key—————>value

HashMap 不排序
TreeMap 排序

map的操作
1.put(key,vaiue)储存数据
2.remove（key）删除数据
3.size（）map存储了多少键值对
4.containsKey（）判断map是否包含了xxxkey
containsvaiue（）判断map是否包含了xxxvaiue
5.如果出现了相同的key，原来的数据会被顶掉
6.keySet（）把map中所有的key打包成set集合返回
7.get（key）通过key查询vaiue

小练习：

开发敏感词过滤程序，提示用户输入评论内容，如发现敏感词用（*）代替，未发现则正常输出。

package Gather.Test;

import javax.jws.soap.SOAPBinding;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Day01 {
    public static void main(String[] args) {
        //敏感词
        List li = new ArrayList();
        li.add("出去");
        li.add("进来");
        li.add("跑掉了");
        li.add("救救我");
        //让用户输入评论内容
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的评论内容：");
        String content = sc.nextLine();

        for (int i = 0; i<li.size();i++){
            String ci = (String) li.get(i);//拿到敏感词
            if (content.contains(ci)){//判断是否包含敏感词

                //拼接*
                String s = "";
                for (int j = 0;j<ci.length();j++){
                    s+="*";
                }
               content = content.replace(ci,s);

            }
        }
        System.out.println(content);
    }
}

迭代器Iterator

set
迭代：一个一个的往出拿
最核心的操作就是：下一个

next（）下一个
hasNext()

package Gather.Irer;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("猫");
        list.add("狗");
        list.add("熊");
        list.add("鹿");

        //创建迭代器
        Iterator it = list.iterator();
//        String s0 = (String) it.next();//第一个
//        System.out.println(s0);
//        String s1 = (String) it.next();//下一个
//        System.out.println(s1);
//        String s2 = (String) it.next();//下一个
//        System.out.println(s2);
//        String s3 = (String) it.next();//下一个
//        System.out.println(s3);
//        String s4 = (String) it.next();//没有了，报错了
//        System.out.println(s4);
        while (it.hasNext()){
            String s = (String) it.next();//拿下一个元素
            System.out.println(s);
        }

//        System.out.println(list);
//
//        for (int i = 0; i<list.size(); i++){
//            String s = (String) list.get(i);
//            System.out.println(s);
        }
    }

package Gather.Irer;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestSet {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("小猫猫");
        set.add("小狗狗");
        set.add("小熊熊");
        set.add("小鹿鹿");
        Iterator it = set.iterator();

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

package Gather.Irer;

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

public class TestMap {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("小猫猫","猫");
        map.put("小狗狗","狗");
        map.put("小熊熊","熊");
        map.put("小鹿鹿","鹿");
        Set set = map.entrySet();//set里面装的是entry
        Iterator it = set.iterator();

        while (it.hasNext()){
            Map.Entry entry = (Map.Entry) it.next();

            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        //方案一
//        Set set = map.keySet();//拿到所有key
//        Iterator it = set.iterator();//拿到迭代器
//        while (it.hasNext()){
//           String key = (String) it.next();//所有的key
//            System.out.println(map.get(key));
//        }

        System.out.println(map.keySet());
    }
}

泛型

规范容器内的数据类型
容器<数据类型>
碗<盐>
Set和List泛型规范是一样的
map有点不一样

package Gather.fan;

import java.util.*;

public class Test {
    public static void main(String[] args) {
//        List<String> strList = new ArrayList<String>();
//        strList.add("小哥哥");
//        //strList.add(123);//不可以装int
//        strList.add("小姐姐");
//        strList.add("老阿姨");
//        String s = strList.get(1);//不需要墙砖了
//        System.out.println(s);
//        List<Singer> list = new ArrayList<Singer>();
//        list.add(new Singer(1,"猫",1.24,"小猫猫"));
//        list.add(new Singer(2,"狗",1.24,"小狗狗"));
//        list.add(new Singer(3,"鹿",1.24,"小鹿鹿"));
//        list.add(new Singer(4,"熊",1.24,"小熊熊"));
//        Iterator<Singer> it = list.iterator();
//        while (it.hasNext()){
//            Singer s = it.next();
//            System.out.println(s.getName());
//            System.out.println(s.getSong());
//        }
        Map<String,String> map = new HashMap<String, String>();
        map.put("老坛酸菜","我的最爱");
        map.put("红烧牛肉","吃吐了");
        map.put("西红柿打卤面","我吃过最难吃的泡面");

        map.put("海鲜面","这个还凑活");

        String s = map.get("老坛酸菜");
        System.out.println(s);



    }
}

package Gather.fan;

public class Singer {
    private int id;
    private String name;
    private double salary;
    private String song;

    public Singer(int id, String name, double salary, String song) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.song = song;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getSong() {
        return song;
    }

    public void setSong(String song) {
        this.song = song;
    }
}

增强for

语法：
for（类型变量：数组或集合）{
循环体
}
优点：代码简洁
缺点：看不到索引

package Gather.TestFor;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        String[] arr = {"Hello","你好","萨瓦迪卡","欧哈己有"};

        for (int i = 0; i<arr.length;i++){
            System.out.println(arr[i]);
        }
        for (String s:arr){
            System.out.println(s);
        }
        List<Integer> lst = new ArrayList<Integer>();
        lst.add(123);
        lst.add(456);
        lst.add(789);
        for (Integer obj :lst){
            System.out.println(obj+100);//还能加减乘除
        }

    }
}

Collections工具类

package Gather.Collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Test {
//可变参数
    public static void chi(String...args){
        for (String s:args){
            System.out.println(s);
        }
    }
    public static void main(String[] args) {
        chi("黄瓜","木瓜","甜瓜");

        List<Integer> lst = new ArrayList<Integer>();
        lst.add(123);
        lst.add(132);
        lst.add(999);
        lst.add(777);

        Integer min = Collections.min(lst);//输出列表最小值
        System.out.println(min);
        Integer max = Collections.min(lst);//输出列表最大值
        System.out.println(max);
        Collections.sort(lst);  //对列表进行排序
        System.out.println(lst);
        Collections.shuffle(lst);//打乱一个列表
        System.out.println(lst);
        Collections.addAll(lst,888,222,333,444);//不定参数
        System.out.println(lst);
    }
}

练习2
1.有字符串“k：1，k1：2，k2：3，k3：4”处理成Map：{‘k’=1,‘k1’=2…}

package Gather.Test;

import java.util.HashMap;
import java.util.Map;

public class HomeWork1 {
    public static void main(String[] args) {
        String str = "k:1,k1:2,k2:3,k3:4";
        //{‘k’=1,‘k1’=2....}
        //{"k:1","k1:2"....}
        String[] strs = str.split(",");
        Map<String ,Integer> map = new HashMap<String, Integer>();
        //对数组循环，拿到每一个切割完成的字符串
        for(String s:strs){//k:1
            String[] ss = s.split(":");//{"k","1"}
            map.put(ss[0],Integer.parseInt(ss[1]));

        }
        System.out.println(map);
    }
}

2.元素分类，有如下值 int[] li = {11,22,33,44,55,66,77,88,99},将所有大于等于66的值保存至Map的第一个key中，将小于66的值保存至第二个key的值中。
即：{‘k1’：大于66的所有值列表，‘k2：’小于66的所有值列表}

package Gather.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HomeWork2 {
    public static void main(String[] args) {
        int[] li = {11,22,33,44,55,66,77,88,99,90};

        Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();
        for (int n:li) {
            if (n >= 66){
                if (!map.containsKey("key1")) {
                map.put("key1", new ArrayList<Integer>());
                }
            //确定map容器里有List
            map.get("key1").add(n);//把数据添加到列表
            }else{
                if (!map.containsKey("key2")){
                map.put("key2",new ArrayList<Integer>());
                }
            map.get("key2").add(n);
        }
    }
        System.out.println(map);
}
}

java java