JAVA第六周小结（下）

最新推荐文章于 2024-07-13 20:43:20 发布

wei_5guang_

最新推荐文章于 2024-07-13 20:43:20 发布

阅读量84

点赞数

文章标签：单例模式 jvm

本文链接：https://blog.csdn.net/wei_5guang_/article/details/130174461

版权

单例模式

要求在整个程序运行过程中，同一个类只出现一个对象。目的减少内存的消耗。

如何查看对象同一个对象？看内存地址。如果内存地址一样就是一个对象

class People {
    private static People people = null;
    //1.对构造方法私有化
    private People () {
        
    }
    //2.写一个静态方法  使用类名直接调用的   不能使用对象来调用的  因为私有化构造方法了
    public static  People getInstance () {
        if (people == null) {
            people = new People();
        }

        return people;
    }

}
public class Demo1 {
    public static void main(String[] args) {
        //当一new就会新建对象，创建唯一的对象，对当前类的无参构造方法加private修饰
        People people = People.getInstance();
        People people1 = People.getInstance();
        System.out.println(people);
        System.out.println(people1);

    }
}

class SingleDog {
    private static SingleDog singleDog;
    private SingleDog() {

    }
    public static synchronized SingleDog getInstance() {
        synchronized (SingleDog.class) {
            if (singleDog == null) {


                //线程1进来了还没有new 呢，结果线程2抢到执行权利的
                //结果线程2 发现singleDog  是空的    new

                singleDog = new SingleDog();
            }
        }

        return singleDog;
    }
}
//在两个线程中去创建单例对象的时候  如果发现对象内存不一样，就证明线程不安全
class Mythread1 implements Runnable {
    @Override
    public void run() {
        SingleDog instance = SingleDog.getInstance();
        System.out.println(instance);//对象的内存地址
    }
}
class Mythread2 implements Runnable {
    @Override
    public void run() {
        SingleDog instance = SingleDog.getInstance();
        System.out.println(instance);//对象的内存地址
    }
}
public class Demo2 {
    public static void main(String[] args) {
        new Thread(new Mythread1()).start();
        new Thread(new Mythread2()).start();
    }
}

Lambda表达式

lambda表达式被称为闭包。函数式编程，就是为了简化代码，让代码更加简洁。

package com.yhs.text;

import java.sql.SQLOutput;

public class Demo8 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {

            @Override
            public void run() {
                System.out.println("呵呵");
            }
        };
        Runnable runnable1 = ()-> System.out.println("福");
        new Thread(runnable).start();
        new Thread(runnable1).start();
    }
}

Lambda表达式的语法格式

函数式接口，接口下面有且只有有一个抽象类，才能使用Lambada

接口接口对象 = ()->表达式; 无参无返回值的接口接口对象 = (parameter)->表达式; 有参无返回值的接口接口对象 = ()->{表达式;} 无参有返回值的接口接口对象 = (parameter)->{表达式;} 有参有返回值的

无参无返回值的

接口接口对象 = ()->表达式; 无参无返回值的

package com.yhs.text;
interface Computer {
    void coding();
}
public class Demo9 {
    public static void main(String[] args) {
        Computer computer = ()-> System.out.println("敲键盘");
        test(()-> System.out.println("嘎嘎乱敲"));
    }
    public static void test (Computer computer) {
        computer.coding();
    }
}

有参无返回值

接口接口对象 = (parameter)->表达式; 有参无返回值的

package com.yhs.text;
interface A {
    void eat (String name, int age);
}
public class Demo1 {
    public static void main(String[] args) {
        test(((name, age) -> System.out.println(name+"年龄为:"+age+",再吃烤鸭:") ),"博博",36);//博博年龄为:36,再吃烤鸭:
    }
    public static void test(A a,String name,int age) {
        a.eat(name, age);
    }
}

无参有返回值

接口接口对象 = ()->{表达式;} 无参有返回值的

package com.yhs.text;
interface B {
    int num();
}
public class Demo2 {
    public static void main(String[] args) {
        test(()->{return 999;});
    }

    public static void test (B b) {
        System.out.println(b.num());//999
    }
}

有参有返回值

接口接口对象 = (parameter)->{表达式;} 有参有返回值的

package com.yhs.text;
interface C {
    int add(int a, int b);
}
public class Demo3 {
    public static void main(String[] args) {
        teat((a, b) -> a + b, 9, 9);
    }


    public static void teat(C c,int a,int b) {
        int sum = c.add(a,b);
        System.out.println(sum);//18
    }
}

Stream流

package com.yhs.text;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        //将list集合  姓张的过滤到另外一个新的集合中
        //然后再将新集合中的名字的长度为3的存到新的集合中
        ArrayList<String> a = new ArrayList<>();
        a.add("张起灵");
        a.add("张日山");
        a.add("张飞");
        a.add("宋三川");
        ArrayList<String> a1 = new ArrayList<>();
        for (String s : a) {
            if (s.startsWith("张")) {
                a1.add(s);
            }
        }
        System.out.println(a1);//[张起灵, 张日山, 张飞]
        ArrayList<String> a2 = new ArrayList<>();
        for (String s : a1) {
            if (s.length()==3) {
                a2.add(s);
            }
        }
        System.out.println(a2);//[张起灵, 张日山]
    }
}

用stream流来写

list.stream(). //把一个集合变成Stream流
filter((name)->name.startsWith("张")). //过滤姓张
filter((name)->name.length() == 3).//过滤长度为3 的
forEach((name)-> System.out.println(name)); //遍历

获取Stream对象

可以根据集合获取流对象

Collection集合：

default Stream<E> stream(); 返回的是一个有顺序的和集合源数据相关的对象

说白了就是将集合中的数据变成了另外一种形式而已（流的形式）

1.根据list集合获取流对象

 ArrayList<String> strings = new ArrayList<>();
        strings.add("狗蛋");
        strings.add("皮皮");
        strings.add("毛球");
        System.out.println(strings);
        //可以list集合变成一个流对象
        Stream<String> stream = strings.stream();
        System.out.println(stream);//内存地址

2.根据Set集合获取流对象

Set<String> sets = new HashSet<>();
        sets.add("hah");
        sets.add("fd");
        sets.add("gg");
        Stream<String> stream1 = sets.stream();
        System.out.println(stream1);

3.根据map集合获取对象

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("狗蛋");
        strings.add("皮皮");
        strings.add("毛球");
        System.out.println(strings);
        //可以list集合变成一个流对象
        Stream<String> stream = strings.stream();
        System.out.println(stream);//内存地址

        Set<String> sets = new HashSet<>();
        sets.add("hah");
        sets.add("fd");
        sets.add("gg");
        Stream<String> stream1 = sets.stream();
        System.out.println(stream1);

        Map<String, String> maps = new HashMap<>();
        maps.put("1", "哈哈");
        maps.put("2", "呵呵");
        maps.put("3", "嘿嘿");
        //map集合没有stream方法，转为集合再来操作
        Set<String> strings1 = maps.keySet();
        Stream<String> stream2 = strings1.stream();
        Collection<String> values = maps.values();
        Stream<String> stream3 = values.stream();
        Set<Map.Entry<String, String>> entries = maps.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entries.stream();
        

    }
}

4.数组

 String[] arr = {"a", "b"};
        //数组也可以变成stream流形式的
        Stream<String> arr1 = Stream.of(arr);

Stream流对象下面的方法

方法就是一个功能

方法的名字	方法的作用	方法种类	是否支持链式操作
count	统计个数	终结方法	否
forEach	遍历数据的	终结方法	否
filter	过滤数据	可以拼接	是
limit	取前几个数据	可以拼接	是
skip	跳过前几个	可以拼接	是
map	映射方法	可以拼接	是
concat	拼接	可以拼接	是

count和forEach

count ：统计流中的个数，返回值是long类型的数据

forEach: 遍历流中数据的

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        Stream<String> stream = strings.stream();
        long count = stream.count();
        System.out.println(count);
        //链式操作
        long count1 = strings.stream().count();
        System.out.println(count1);
        //froEach
        //对此流的每个元素执行操作
        strings.stream().forEach(new Consumer<String>() {
            @Override
            //将流中的数据 赋值 s
            public void accept(String s) {
                System.out.println(s);
            }
        });
        strings.stream().forEach((s)-> System.out.println(s));

    }

filter方法

Stream<T> filter(Predicate<? super T> predicate)

返回由与此给定谓词匹配的此流的元素组成的流

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");

        strings.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //s流中字符串每个的数据
                boolean b = s.endsWith("坤");

                return b;
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean c = s.startsWith("陈");
                return c;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        strings.stream().filter((goudan)->goudan.endsWith("坤")).filter((s)->s.startsWith("陈")).forEach((s)-> System.out.println(s));
    }
}

limit方法

限制输出

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");
        strings.add("小坤");
        strings.add("大坤坤");
        strings.add("爱坤");
        //limit 是要前几个数据 根据参数不同
        strings.stream().limit(5).forEach((s)-> System.out.println(s));
        strings.stream().limit(5).filter((s)->s.endsWith("坤")).forEach((s)-> System.out.println(s));
    }
}

map方法

处理映射关系的

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("12");
        strings.add("13");
        strings.add("14");
        strings.add("15");
        //将字符串数字 转为int类型的数据
//        for (String string : strings) {
//
//            int i = Integer.parseInt(string);
//            System.out.println(i);
//        }
        strings.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
        }).forEach((Integer s)-> System.out.println(s));

        strings.stream().map((s)->Integer.parseInt(s)).forEach((s)-> System.out.println(s));

    }

skip方法

跳过前几个值

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("12");
        strings.add("13");
        strings.add("14");
        strings.add("15");
        strings.stream().skip(2).forEach((s)-> System.out.println(s));
        
    }
}

concat合并两个流

 public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("12");
        list1.add("13");
        list1.add("14");
        list1.add("15");
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        Stream<String> stream = list1.stream();
        Stream<String> stream1 = strings.stream();
        //将两个流合并
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach((s)-> System.out.println(s));
    }
}

收集流

stream.collect(Collectors.toList())

stream.collect(Collectors.toSet())

toList(); 将流转为List集合

toSet(); 将流转为Set集合

因为真实的开发的时候，最终的结果还是集合流只是扮演了中间处理数据的角色

 public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("刘亦菲");
        strings.add("蔡徐坤");
        strings.add("成龙");
        strings.add("杨坤");
        strings.add("陈坤");
        strings.add("小坤");
        strings.add("大坤坤");
        strings.add("爱坤");
        strings.add("爱坤");
        //collect  收集的方法
        //stream.collect(Collectors.toList()) 以什么样的方式收集
        List<String> list = strings.stream().filter((s) -> s.endsWith("坤")).skip(2).collect(Collectors.toList());
        System.out.println(list);
        Set<String> set = strings.stream().filter((s) -> s.endsWith("坤")).skip(2).collect(Collectors.toSet());
        System.out.println(set);

    }
}