容器

容器：能装对象的对象

List 线性结构，可变长度
Set 集合，非线性，去除重复
Map 映射，存储的时候以key value的形式存储数据

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

List

ArrayList -> 列表

LinkedList -> 链表

列表可以存放重复的数据，按照我们存储的顺序进行存储

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

public class TestList {
    public static void main(String[] args){
        List list = new ArrayList(); // 更多使用ArrayList
        List list1 = new LinkedList(); // 操作都是一样的 只是存储方式不同

        list.add("福满多"); // 增加元素
        list.add("小当家"); // 增加元素
        list.add("康师傅"); // 增加元素
        list.add("汤达人"); // 增加元素
//        System.out.println(list);
//        list.remove("小当家");
//        System.out.println(list); // 删除元素
//        System.out.println(list.size()); // 查询列表大小（包含了多少个元素）
//        // 列表的下标也是从0开始
//        Object obj = list.get(1); // 从列表中获取到某个元素
//        String s = (String)obj;
//        System.out.println(s);
//        System.out.println(list.contains("康师傅")); // 判断是否有xxx元素

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

运行结果：

Set集合

HashSet

无序，乱的，不重复

TreeSet

默认进行排序，不重复

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

public class Test {
    public static void main(String[] args) {
        Set s = new HashSet(); // 主要使用HashSet
        Set s1 = new TreeSet();

        s.add(123); // 添加元素
        s.add(147);
        s.add(3);
        s.add(147); // 重复的数据添加不进去
        System.out.println(s.size()); // 查询元素的个数
        s.remove(3); // 删除元素
        System.out.println(s);
        System.out.println(s.contains(123)); // 是否包含xxx
    }
}

运行结果:

Map容器

名字 -> 电话

key -> value

HashMap 不排序

TreeMap 排序

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

public class Test {
    public static void main(String[] args) {
//        Map map = new HashMap();
//        map.put("jay","周杰伦"); // 储存数据
//        map.put("wf","汪峰");
//        map.put("tz","陶喆");
//        System.out.println(map);
        Map map = new TreeMap();
        map.put(11,"周杰伦"); // 储存数据
        map.put(22,"汪峰");
        map.put(33,"陶喆");
        map.put(66,"提莫");
        // 如果出现了相同的key，原来的数据会被顶掉
        map.put(66,"鸡你太美"); // 通过key查询value
        System.out.println(map.get(66));
        System.out.println(map.keySet()); // 把map中的所有的key打包成set集合返回
        System.out.println(map);
        System.out.println(map.size()); // 储存了多少个键值对
        map.remove(33); // 删除数据
        System.out.println(map);
        System.out.println(map.containsKey(11)); // 判断map是否包含了xxxkey
        System.out.println(map.containsValue("周杰伦")); // 判断map是否包含了xxxvalue
    }
}

运行结果：

练习替换铭感字体为*

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

public class Test1 {
    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

迭代：一个一个往出拿

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

运行结果：

Set

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

运行结果：

Map

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("11","蔡徐坤");
        map.put("22","吴亦凡");
        map.put("33","李易峰");
        map.put("66","鹿晗");
        // 方案一
//        Set set = map.keySet(); // 拿到所有的key
//        Iterator it = set.iterator(); // 拿到迭代器
//
//        while (it.hasNext()){
//            String key = (String) it.next(); // 所有的key
//            System.out.print(map.get(key)); // 通过key获取到value
//        }
        // 方案二
        Set set1 = map.entrySet();
        Iterator it1 = set1.iterator();

        while (it1.hasNext()){
            Map.Entry entry = (Map.Entry) it1.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

运行结果：

泛型

规范容器内的数据类型

写法：容器<数据类型>

例如：碗<盐>

Set和List泛型规范是一样的

Map有一点不同

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

import java.util.*;

public class Test {
    public static void main(String[] args){
//        List<String> strList = new ArrayList<String>();
//        strList.add("吴亦凡");
//        strList.add(111); // 上面设置了String 不可以装int
//        strList.add("蔡徐坤");
//        strList.add("李易峰");
//        String s = strList.get(1); // 明确了String 就不需要强转
//        System.out.println(s);
          // Singer类也可以使用
//        List<Singer> list = new ArrayList<Singer>();
//        list.add(new Singer(1,"蔡徐坤",1.25,"只因你太美"));
//        list.add(new Singer(2,"吴亦凡",1.25,"又大又圆"));
//
//        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("红烧牛肉","海星");
        String s = map.get("老坛酸菜");
        System.out.println(s);
    }
}

运行结果：

增强for

语法：

for:(类型：数组或集合){

循环体

}

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
//        for (String s : arr){
//            System.out.println(s);
//        }
        // 不能写int 不是对象
        List<Integer> list = new ArrayList<Integer>();
        list.add(123);
        list.add(456);
        list.add(789);
        // 缺点 无法看到索引
        for (Integer s : list){
            System.out.println(s);
        }
    }
}

运行结果：

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> list = new ArrayList<Integer>();
        list.add(123);
        list.add(456);
        list.add(789);
        list.add(148);

        Integer min = Collections.min(list); // 最小值
        Integer max = Collections.max(list); // 最大值
        System.out.println(""+min+max);

        Collections.sort(list);
        System.out.println(list); // 排序 升序

        Collections.shuffle(list); // 打乱一个列表 比如斗地主随机牌
        System.out.println(list);

        Collections.addAll(list,135,246,468); // 添加不定参数
        System.out.println(list);
    }
}

运行结果：

练习

练习1

import java.util.Map;
import java.util.TreeMap;

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 TreeMap<String,Integer>();
        // 对数组循环，拿到每一个切割完成的字符串
        for (String s : strs){ // k:1
            String[] ss = s.split(":");
            map.put(ss[0],Integer.parseInt(ss[1]));
        }
        System.out.println(map);
    }
}

运行结果：

练习2

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){
                // 判断是否存在key1，如果不存在，创建一个新的进去
                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);
    }
}

运行结果：

posted @ 2021-05-18 00:19 闲着的大叔阅读(120) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

闲着的大叔

容器

容器

List

Set集合

Map容器

迭代器Iterator

泛型

增强for

Collections工具

练习

公告