【无标题】

最新推荐文章于 2024-06-13 08:37:22 发布

知意..

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量64

点赞数 1

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_74748121/article/details/128344928

版权

一.集合:

1.list与set集合:

(1).集合常用API演示:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;


public class Api {
    public static void main(String[] args) {
        //HashSet: 添加元素 无序 不可重复 无索引
        Collection<String> list1 = new ArrayList<>();
        list1.add("java");
        list1.add("java");
        list1.add("myjava");
        list1.add("dddd");
        System.out.println(list1);

        //2.清空集合
        // list1.clear();
        //System.out.println(list1);

        //3.判断集合是否为空
        list1.isEmpty();
        System.out.println(list1.isEmpty());

        //4. 判断集合大小
        list1.size();
        System.out.println(list1.size());

        //5.判断集合中是否存在某个元素
        System.out.println(list1.contains("java"));

        //6.删除某个元素(如果集合中有多个,只会删除一个)
        System.out.println(list1.remove("java"));
        System.out.println(list1);

        //7.把集合转化为数组
        Object[] arrs = list1.toArray();
        System.out.println("数组:" + Arrays.toString(arrs));

        //8.合并集合
        Collection<String> list2 = new ArrayList<>();
        list2.add("嘿嘿");
        list2.add("嘻嘻");
        list1.addAll(list2);
        System.out.println(list1);
        System.out.println(list2);

    }
}

(2).集合遍历方法演示介绍:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;


public class ddd {
    public static void main(String[] args) {
        Collection<String> list1 = new ArrayList<>();
        list1.add("java1");
        list1.add("java2");
        list1.add("myjava");
        list1.add("dddd");
        System.out.println(list1);
        //得到迭代器对象
        Iterator<String> it = list1.iterator();
        //String s=it.next();
        //next 一一获取
        //遍历
        /*System.out.println(s);
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println("-------------------");*/
        //定义while循环
        //1.遍历迭代器

        while (it.hasNext()) {
            String s = it.next();
            // System.out.println(s);

        }
        //2.增强for循环--(foreach)
        //可以遍历集合和数组

        for (String s : list1) {
            System.out.println(s);
        }
        System.out.println("----------");
        double[] arr = {1.1, 23.2, 65.2, 36.2};
        for (double v : arr) {
            System.out.println(v);
        }
        //3.Lambada表达式:forEach
        //(1).
        /*list1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s2) {
                System.out.println(s2);
            }
        });*/
        //(2).
       /* list1.forEach((String s2)-> {
                System.out.println(s2);
            });*/
        //(3).
        //list1.forEach( s2->   System.out.println(s2));
        //(4).
        list1.forEach(System.out::println);

    }
}

(3)LinkedList特有API:

import java.util.LinkedList;
//LinkedList特有API

public class Three {
    public static void main(String[] args) {
        //1.LinkedList

        LinkedList<String> linkedList = new LinkedList<>();
        //进栈(addFirst)<==>push
        linkedList.push("1子弹");
        linkedList.push("2子弹");
        linkedList.push("3子弹");
        linkedList.push("4子弹");
        linkedList.push("5子弹");
        System.out.println(linkedList);
        //出栈
        System.out.println(linkedList.pop());
        System.out.println(linkedList.pop());
        System.out.println(linkedList.pop());
        System.out.println(linkedList);
        System.out.println("-------------");

        //2.队列
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        queue.addLast("4号");
        queue.addLast("5号");
        System.out.println(queue);
        //出队
        System.out.println(queue.pop());
        System.out.println(queue.pop());
        System.out.println(queue.pop());
        System.out.println(queue);
        System.out.println("------------------");


    }
}

2.Map集合:

(1).主要API演示:

import java.util.*;

public class Api1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        //1.添加:
        map.put("鸿星尔克", 1);
        map.put("枸杞", 50);
        map.put("Java", 55);
        map.put("华为", 100);
        System.out.println(map);
        System.out.println("----------------");
        //2.清空集合
       /* map.clear();
        System.out.println(map);
        System.out.println("----------------");*/
        //3.判断集合是否为空,为空返回true
        System.out.println(map.isEmpty());
        System.out.println("----------------");
        //4.根据键获取对应值:punilc Vget(Object  key)
        Integer key1 = map.get("华为");
        Integer key2 = map.get("java");
        System.out.println(key1);
        //没有返回null
        System.out.println(key2);
        System.out.println("----------------");
        //5.根据键删除整个元素
        /*System.out.println(map.remove("Java"));
        System.out.println(map);
        System.out.println("----------------");*/
        //6.判断是否包含某个键,包含返回true,反正返回flase
        System.out.println(map.containsKey("鸿星尔克"));
        System.out.println(map);
        System.out.println("----------------");
        //7.判断是否包含某个值
        System.out.println(map.containsValue(50));
        System.out.println(map.containsValue(55));
        System.out.println(map.containsValue(100));
        System.out.println("----------------");
        //8.获取全部键集合  public Set <K> keySet()//把所有键拿到一个集合
        Set<String> keys = map.keySet();
        System.out.println(keys);
        System.out.println("----------------");
        //9.获取全部键集合 Collection<V>values   把所有值拿到一个集合
        Collection<Integer> values = map.values();
        System.out.println(values);
        System.out.println("----------------");
        //10.集合的大小
        System.out.println(map.size());
        System.out.println("----------------");
        //11.合并其他集合
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("java1", 1);
        map1.put("java2", 100);
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("java2", 1);
        map2.put("java3", 100);
        map1.putAll(map2);//把map2中的元素拷贝一份到map1中---后加的会覆盖前加的
        System.out.println(map1);
        System.out.println(map2);
    }
}

(2).Map集合遍历跟list和set遍历类似

3.选择排序:

(1).Apple类:

public class Apple implements Comparable<Apple> {
    private String color;
    private String name;
    private int weight;
    private double price;

    public Apple() {

    }

    public Apple(String color, String name, int weight, double price) {
        this.color = color;
        this.name = name;
        this.weight = weight;
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "color='" + color + '\'' +
                ", name='" + name + '\'' +
                ", weight=" + weight +
                ", price=" + price +
                '}';
    }

    //F方式1:类定义比较规则
    //o1.compareTo(o2)
    @Override
    public int compareTo(Apple o) {
        //去掉重量相同的元素对象
        return this.weight - o.weight;
       // return this.weight - o.weight >= 0 ? 1 : -1;

    }
}

注意:重写toString方法

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class set4 {
    public static void main(String[] args) {
        //目标:TreeSet如何排序(Integer)基本数据类型类似
        //自定义排序
        //基于红黑树排序
        Set<Integer> set = new TreeSet<>(); //TreeSet: 可排序不重复  无索引
        set.add(23);
        set.add(32);
        set.add(12);
        set.add(25);
        set.add(4);
        System.out.println(set);
        System.out.println("-*------------------");
        Set<String> set1 = new TreeSet<>(); //TreeSet: 可排序不重复  无索引
        //按照编号A<a
        set1.add("Double");
        set1.add("Apple");
        set1.add("apple");
        set1.add("True");
        set1.add("Flase");
        set1.add("嘿嘿");
        System.out.println(set1);
        System.out.println("-*------------------");
        //学生类自定义排序
        Set<Apple> set2 = new TreeSet<>(new Comparator<Apple>() {
            //集合自带的比较规则
            //若类和集合都写了比较规则,就近原则
            @Override
            public int compare(Apple o1, Apple o2) {
                //return o1.getWeight()-o2.getWeight();//升序
                //return o2.getWeight()-o1.getWeight();//降序
                //return Double.compare(o2.getPrice(),o1.getPrice());//降序
               return Double.compare(o2.getPrice(),o1.getPrice());//升序
                //注意: 浮点型直接用 Double.compare()比较

            }
        });
        //简化排序
        Set<Apple> set3 = new TreeSet<>((o1, o2) -> Double.compare(o2.getPrice(),o1.getPrice()));

        set2.add(new Apple("绿色", "大白", 1, 3.4));
        set2.add(new Apple("红色", "小白", 2, 2.3));
        set2.add(new Apple("黄色", "中白", 3, 4.5));
        set2.add(new Apple("红绿色", "小小白", 1, 2.3));
        System.out.println(set2);
    }
}

4.Stream:

(1).常用API:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;
//中间方法
public class Api {
    public static void main(String[] args) {
        List<String>list=new ArrayList<>();
        list.add("周芷若");
        list.add("张无忌");
        list.add("苏苏");
        list.add("赵敏");
        list.add("张柏");
        list.add("张三丰");
        list.add("张三丰");

        list.stream().filter( s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        System.out.println("-----------------------");
        //2.统计个数
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);
        System.out.println("-----------------------");
        //3.去前几个元素

        //list.stream().filter( s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
            //当遍历时 s和打印的s一样可以如下
        list.stream().filter( s -> s.startsWith("张")).limit(2).forEach( System.out::println);
        System.out.println("-----------------------");
            //跳过前几个元素
        list.stream().filter( s -> s.startsWith("张")).skip(2).forEach( System.out::println);
        System.out.println("-----------------------");
        //map加工方法:  第一个参数时原来的元素   第二个元素时加工后的结果
        //各级和元素前加一个  "666"
        list.stream().map(s -> "666:"+s).forEach(a -> System.out.println(a));
        //把名做成学生对象:
        list.stream().map(s -> new Student()).forEach(s -> System.out.println(s) );
        System.out.println("-------------------");
        //合并
        Stream<String>s1=list.stream().filter(s -> s.startsWith("张"));
        Stream<String>s2=Stream.of("java1","java2");
        Stream<String>s3=Stream.concat(s1,s2);
        s3.forEach(s -> System.out.println(s));

    }
}

(2).获取Stream流:

//1.获取Stream流(调用方法)
//创建一个流水线
//集合:
//数组:
//2.中间方法
//各项操作
//3.终结方法
//任务完成--如(forEach--遍历)--收尾
public class GetStream {
    public static void main(String[] args) {
        //1.Collection集合的流获取
        Collection<String>list=new ArrayList<>();
        Stream<String>s= list.stream();
        //2.Map集合的流获取
        Map<String,Integer>maps=new HashMap<>();
        //键流
        Stream<String> keyStream = maps.keySet().stream();
        //值流
        Stream<Integer> valueStream = maps.values().stream();
        //整体流
        Stream<Map.Entry<String, Integer>> stream = maps.entrySet().stream();
        //3.数组流的获取
        String[]names={"赵敏","周芷若","素素"};
        //(1).
        Stream<String> nameStream = Arrays.stream(names);
        //(2).
        Stream<String>nameStream2=Stream.of(names);



    }
}