Java高级_Day19(Stream，Optional，类加载器)

最新推荐文章于 2024-08-26 16:40:46 发布
最新推荐文章于 2024-08-26 16:40:46 发布
阅读量126 收藏
点赞数
分类专栏： Java高级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47469183/article/details/113187574
版权

Java高级_Day19(Stream，Optional，类加载器)

Stream

Java8 新特性：Lambda表达式 StreamAPI
Stream是Java中处理集合的关键的一个抽象的概念，它可以指定我们希望对集合执行的一些操作，可以执行一些非常复杂的查找 过滤和映射数据的相关操作，使用Stream对集合数据进行操作，类似于SQL与查询数据库。可以是用Stream API来执行相关操作.
Stream提供了一种高效且以用的处理数据的方式

为什么要使用Stream:

随着技术的发展，特别是NOSQL技术的出现，导致数据的处理，需要延迟到java层面。
Stream和Collection集合的区别：
Collection是一种静态的内存数据结构，面向内存，存储在内存中
Stream是对数据进行相关计算，面向CPU的，通过CPU实现数据的处理计算
集合侧重点数据，Stream的侧重点是计算

Stream的常见操作

  1. 创建Stream
    一个数据源（集合 数组等）获取一个Stream
  2. 中间操作
    中间操作是一个操作链，对数据源进行相应的处理
  3. 终止操作
    一旦执行终止操作，中间操作链就会产生执行的结果，之后不会再被使用
一系列的中间操作
数据源
Find
Filite
Map
终止

Stream的创建:

方式一：通过集合

返回值类型方法
default StreamparallelStream() 返回可能并行的 Stream与此集合作为其来源。
default Streamstream() 返回以此集合作为源的顺序 Stream 。
@Test
public void createSteam1(){
    List<Emp>  empList = new ArrayList<>();
    //顺序 Stream
    Stream<Emp> empStream = empList.stream();
    //并行的 Stream
    Stream<Emp> empStream1 = empList.parallelStream();
}

方式二：通过数组

返回值类型方法
static Streamstream(T[] array) 返回顺序Stream与指定的数组作为源。
static IntStreamstream(int[] array)返回顺序IntStream与指定的数组作为源。
static DoubleStreamstream(double[] array) 返回顺序DoubleStream与指定的数组作为源。
static LongStreamstream(long[] array) 返回顺序LongStream与指定的数组作为源。
@Test
public void createSteam2(){ 
    //基本数据类型
    int[] arr = new int[]{1,2,3,4,5,6};
   	IntStream intStream =  Arrays.stream(arr);
   	// 对象数组
    Emp[] emps = new Emp[2];
    Emp emp1 = new Emp(1001,"admin");
    Emp emp2 = new Emp(1002,"tom");
    emps[0] = emp1;
    emps[1] = emp2;
   	Stream<Emp> empStream = Arrays.stream(emps);
}

方式三：通过Stream的of()

返回值类型方法
static Streamof(T... values) 返回其元素是指定值的顺序排序流。
static Streamof(T t) 返回包含单个元素的顺序 Stream
@Test
public void createSteam3(){
 	Stream<Integer> stream =   Stream.of(1,2,3,4,5);
}

方式4：创建一个无限流（了解）

返回值类型方法
static Streamiterate(T seed, UnaryOperator<T> f) 返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等
static Streamgenerate(Supplier<T> s) 返回无限顺序无序流，其中每个元素由提供的 Supplier 。
@Test
public void createSteam4(){
     //迭代
   	Stream<Integer> integerStream =  Stream.iterate(0,x->x+2);
   	integerStream.limit(10).forEach(System.out::println);
   	// 生成
    Stream<Double> doubleStream = Stream.generate(Math::random);
    doubleStream.limit(10).forEach(System.out::println);
}

Stream的中间操作：

中间操作是一个链式操作，在中间操作的过程中，不会产生任何结果，直到执行终止操作，然后进行一次性的处理，称为”惰性求值”

  1. 筛选和切片
返回值类型方法
Streamfilter(Predicate<? super T> predicate) 接收一个lambda表达式，排除一些元素
Streamdistinct() 筛选，通过流生成元素的hashcode和equals去除重复元素
Streamlimit(long maxSize) 截断流，限制流中的元素的数量不能超过给定值
Streamskip(long n) 跳过元素 返回一个抛弃前n个元素的流，如果流中的元素小于n 就会返回一个空的Stream 与limit进行了一个互补的
package cn.lanqiao.stream;

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

/**
 * @author Hou
 */
public class Emp {
    private int num;
    private String name;
    private int age;
    private int salary;
    public Emp() {
    }

    public Emp(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public Emp(int num, String name, int age, int salary) {
        this.num = num;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    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 int getSalary() {
        return salary;
    }

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

    @Override
    public String toString() {
        return "Emp{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Emp emp = (Emp) o;
        return num == emp.num &&
                age == emp.age &&
                salary == emp.salary &&
                Objects.equals(name, emp.name);
    }

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

    public static List<Emp> empList(){
        List<Emp> empList = new ArrayList<>();
        Emp e1 = new Emp(1001,"马云",50,12000);
        Emp e2 = new Emp(1001,"马化腾",40,8000);
        Emp e3 = new Emp(1001,"雷军",45,9000);
        Emp e4 = new Emp(1001,"李彦宏",35,15000);
        Emp e5 = new Emp(1001,"任正非",60,20000);
        empList.add(e1);
        empList.add(e2);
        empList.add(e3);
        empList.add(e4);
        empList.add(e5);
        return  empList;
    }
}

package cn.lanqiao.stream;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.stream.Stream;

/**
 * @author Hou
 */
public class StreamDemo2 {
    Stream<Emp> empStream;
    List<Emp> empList;
    @BeforeEach
    public void init(){
        empList = Emp.empList();
        //创建stream
        empStream = empList.stream();
    }
    //获取薪资大于10000的员工
    @Test
    public  void  filterTest(){
        //执行过滤操作
        empStream.filter(e->e.getSalary()>10000).forEach(System.out::println);
    }
    // 获取集合中的3名员工
    @Test
    public  void limitTest(){
        empStream.limit(3).forEach(System.out::println);
    }
    //跳过指定的元素
    @Test
    public void skipTest(){
        empStream.skip(3).forEach(System.out::println);
    }
    //筛选 distinct  注意必须重写对象hashCode和Equals

    @Test
    public void distinctTest(){
        empList.add(new Emp(1010,"刘强东",40,8000));
        empList.add(new Emp(1010,"刘强东",40,8000));
        empList.add(new Emp(1010,"刘强东",40,8000));
        empList.add(new Emp(1010,"刘强东",40,8000));
        empList.add(new Emp(1010,"刘强东",40,8000));
        // 去除集合中的重复元素
        empStream.distinct().forEach(System.out::println);
    }
}
  1. 映射
返回值类型方法
Streammap(Function<? super T,? extends R> mapper) 返回由给定函数应用于此流的元素的结果组成的流。
DoubleStreammapToDouble(ToDoubleFunction<? super T> mapper) 返回一个 DoubleStream ，其中包含将给定函数应用于此流的元素的结果。
IntStreammapToInt(ToIntFunction<? super T> mapper) 返回一个 IntStream ，其中包含将给定函数应用于此流的元素的结果。
LongStreammapToLong(ToLongFunction<? super T> mapper) 返回一个 LongStream ，其中包含将给定函数应用于此流的元素的结果。
StreamflatMap(Function<? super T,? extends Stream<? extends R>> mapper) 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
@Test
    public void mapTest1(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);
        //获取员工姓名的长度大于2的员工
        Stream<String> nameStream = empStream.map(Emp::getName);
        nameStream.filter(name->name.length() > 2).forEach(System.out::println);
    }
    @Test
    public void mapTest2(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        Stream<Stream<Character>> ss = list.stream().map(StreamDemo3::fromStringToStream);
        ss.forEach(s->s.forEach(System.out::println));
    }
    @Test
    public void mapTest3(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        Stream<Character> ss = list.stream().flatMap(StreamDemo3::fromStringToStream);
        ss.forEach(System.out::println);
    }
    // 将字符串中的多个字符构成的集合转换为Stream
    public static Stream<Character> fromStringToStream(String str){
        List<Character> list = new ArrayList<>();
        char[] charArray= str.toCharArray();
        for(Character c : charArray){
            list.add(c);
        }
        return  list.stream();
    }
  1. 排序
返回值类型方法
Streamsorted() 返回由此流的元素组成的流，根据自然顺序排序。
Streamsorted(Comparator<? super T> comparator) 返回由该流的元素组成的流，根据提供的 Comparator进行排序。
// 排序  自然排序
    @Test
    public  void sortedTest(){
        List<Integer> list = Arrays.asList(21,12,25,42,20,2,35);
        list.stream().sorted().forEach(System.out::println);
    }
    // 对自定义对象的定制排序  对员工按照年龄排序  如果年龄相同 则按照薪资排序
    @Test
    public  void sortedTest2(){
        empStream.sorted((e1,e2)->{
            Integer ageValue =   Integer.compare(e1.getAge(),e2.getAge());
            if(ageValue != 0){
                return ageValue;
            }else{
                return  Integer.compare(e1.getSalary(),e2.getSalary());
            }
        }).forEach(System.out::println);
    }

终止操作：

  1. 匹配和查找：
返回值类型方法
booleanallMatch(Predicate<? super T> predicate) 检查是否有匹配的元素
booleananyMatch(Predicate<? super T> predicate) 检查至少有一个匹配元素
booleannoneMatch(Predicate<? super T> predicate) 检查是否没有匹配元素
OptionalfindAny() 返回任意一个元素
OptionalfindFirst() 返回第一个元素
long count()返回此流中的元素数void forEach(Consumer<? super T> action)

对此流的每个元素执行操作。
Optional|max(Comparator<? super T> comparator) 根据提供的 Comparator返回此流的最大元素。
Optional|min(Comparator<? super T> comparator) 根据提供的 Comparator返回此流的最小元素。

@Test
    // 检查员工的年龄是否都大于18岁
    public void test1(){
        boolean allMatch = empStream.allMatch(e->e.getAge()> 18);
        System.out.println(allMatch);
    }
    @Test
    // 检查员工的薪资是否有低于5000
    public void test2(){
        boolean anyMatch = empStream.anyMatch(e->e.getSalary()<5000);
        System.out.println(anyMatch);
    }
    @Test
    // 检查员工的姓名中是否存在姓”张“
    public void test3(){
        boolean noneMatch = empStream.noneMatch(e->e.getName().startsWith("张"));
        System.out.println(noneMatch);
    }
    @Test
    // 返回第一个元素
    public void test4(){
        Optional<Emp> empOptional = empStream.findFirst();
        System.out.println(empOptional);
    }
    @Test
    // 返回任意一个元素
    public void test5(){
        Optional<Emp> empOptional = empList.parallelStream().findAny();
        System.out.println(empOptional);
    }
  1. 归约：
返回值类型方法
Treduce(T identity, BinaryOperator<T> accumulator) 将流中的元素反复的处理，得到一个值T
Optionalreduce(BinaryOperator<T> accumulator) 将流中的元素反复的处理，得到一个值Optional
@Test
    // 计算1--10的自然数的和
    public void test6(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer s = list.stream().reduce(0,Integer::sum);
        System.out.println(s);
    }
    @Test
    //  计算所有员工的薪资总和
    public void test7(){
        Stream<Integer> salarys = empStream.map(Emp::getSalary);
        Optional<Integer> salarySum = salarys.reduce((d1,d2)->d1 +d2);
        System.out.println(salarySum);
    }
  1. 收集：
返回值类型方法
<R,A> Rcollect(Collector<? super T,A,R> collector) 使用 Collector对此流的元素执行 mutable reduction Collector 。
 @Test
    //  查找员工的薪资大于9000 并返回为一个List或set
    public void test8(){
        List<Emp>  emps =   empStream.filter(e->e.getSalary()>9000).collect(Collectors.toList());
        System.out.println(emps);
    }
    @Test
    public void test9(){
        Set<Emp> empSet =   empStream.filter(e->e.getSalary()>9000).collect(Collectors.toSet());
        empSet.forEach(System.out::println);
    }

Optional

Class Optional<T>

Optional是一个容器类，它可以保存类型为T的值，则代表这个值存在，或者仅仅保存为null 表示这个值不存在，原来用null表示一个值不存在，现在Optional可以更好的来表达这个概念，并且还可以避免空指针异常的出现

Optional的常用方法：

创建：

返回值类型方法
static Optionalof(T value) 返回具有 Optional的当前非空值的Optional。
static Optionalempty() 返回一个空的 Optional实例。
static OptionalofNullable(T value) 返回一个 Optional指定值的Optional，如果非空，则返回一个空的 Optional 。

判断Optional容器中是否包含对象 ：

返回值类型方法
booleanisPresent() 返回 true如果存在值，否则为 false 。

获取对象 ：

返回值类型方法
Tget() 如果 Optional中有一个值，返回值，否则抛出 NoSuchElementException 。
TorElse(T other) 返回值如果存在，否则返回 other 。
TorElse(T other) 返回值如果存在，否则返回 other 。
TorElseGet(Supplier<? extends T> other) 返回值如果存在，否则返回 other 。

使用：

public class OptionalDemo1 {
    @Test
    public void test1(){
        Emp e1 = new Emp(1001,"马云",50,12000,new Dept(10,"总裁办"));
        Emp e4 = new Emp(1001,"李彦宏",40,15000,null);
        Optional<Dept> opt = Optional.ofNullable(e1.getDept());
        // 如果有部门信息就打印，没有则不打印
        opt.ifPresent(System.out::println);
        Optional<Dept> opt1 = Optional.ofNullable(e4.getDept());
        opt1.ifPresent(System.out::println);
    }
    @Test
    public void test2(){
        Emp e1 = new Emp(1001,"马云",50,12000,new Dept(10,"总裁办"));
        Emp e4 = new Emp(1001,"李彦宏",40,15000,null);
        Optional<Dept> opt = Optional.ofNullable(e1.getDept());
        Dept dept = opt.orElse(new Dept(50,"秘书处"));
        // 如果有部门信息就打印，没有则不打印
        opt.ifPresent(System.out::println);
        Optional<Dept> opt1 = Optional.ofNullable(e4.getDept());
        Dept dept1 = opt1.orElse(new Dept(50,"秘书处"));
        System.out.println(dept1);
    }
    @Test
    public void test3(){
        Emp e1 = new Emp(1001,"马云",50,12000,new Dept(10,"总裁办"));
        Emp e4 = new Emp(1001,"李彦宏",40,15000,null);
        Optional<Emp> opt = Optional.ofNullable(e4);
        // 判断Optinal中Emp对象是否满足条件，如果满足则保留并打印这个对象  否则就返回空
        Optional<Emp> empOpt=  opt.filter(e->e.getSalary() > 12000);
        System.out.println(empOpt);

    }
    @Test
    public void test4(){
        Emp e1 = new Emp(1001,"马云",50,12000,new Dept(10,"总裁办"));
        Emp e4 = new Emp(1001,"李彦宏",40,15000,null);
        Optional<Emp> opt = Optional.ofNullable(e1);
        // 如果Optional中的Emp对象 不为空，就为其翻倍
        Optional<Emp> empOptional = opt.map(e->{
            e.setSalary(e.getSalary()*2);
            return  e;
        });
        System.out.println(empOptional);
    }
}

类加载器

类加载【理解】

类加载的描述：

  • 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

类的加载：

  • 就是指将class文件读入内存，并为之创建一个 java.lang.Class 对象
  • 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象

类的连接

  • 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
  • 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
  • 解析阶段：将类的二进制数据中的符号引用替换为直接引用

类的初始化

  • 在该阶段，主要就是对类变量进行初始化

类的初始化步骤

  • 假如类还未被加载和连接，则程序先加载并连接该类
  • 假如该类的直接父类还未被初始化，则先初始化其直接父类
  • 假如类中有初始化语句，则系统依次执行这些初始化语句
  • 注意：在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3

类的初始化时机

  • 创建类的实例
  • 调用类的类方法
  • 访问类或者接口的类变量，或者为该类变量赋值
  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
  • 初始化某个类的子类
  • 直接使用java.exe命令来运行某个主类

类加载器【理解】

类加载器的作用：

负责将.class文件加载到内存中，并为之生成对应的 java.lang.Class 对象。虽然我们不用过分关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行！

JVM的类加载机制：
  • 全盘负责：就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
  • 父类委托：就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
  • 缓存机制：保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区
Java中的内置类加载器:
  • Bootstrap class loader：它是虚拟机的内置类加载器，通常表示为null ，并且没有父null
  • Platform class loader：平台类加载器可以看到所有平台类 ，平台类包括由平台类加载器或其祖先定义的JavaSE平台API，其实现类和JDK特定的运行时类
  • System class loader：它也被称为应用程序类加载器 ，与平台类加载器不同。 系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类
  • 类加载器的继承关系：System的父加载器为Platform，而Platform的父加载器为Bootstrap
ClassLoader 中的两个方法:
方法名说明
static ClassLoader getSystemClassLoader()返回用于委派的系统类加载器
ClassLoader getParent()返回父类加载器进行委派
public static void main(String[] args) {
 	ClassLoader loader =   ClassLoader.getSystemClassLoader();
    System.out.println(loader);//AppClassLoader
    ClassLoader loader1 = loader.getParent();
    System.out.println(loader1);//PlatformClassLoader
    ClassLoader loader2 = loader1.getParent();
    System.out.println(loader2);//NULL Bootstrap class loader
}

在这里插入图片描述
类加载器:
在这里插入图片描述
BootstrapClassLoader 称为引导类加载器，用C++语言编写，是jvm自带的类加载器，负责Java平台的核心库，用来加载核心类库，该类加载器无法直接获取， 获取的时候返回的是null
Extension ClassLoader 负责jre/lib/ext目录下的类的加载
System ClassLoader 负责自定义的类，引入的jar包的相关类的加载 是使用最多的一个加载器

hrh1276
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA日期类求年龄并求出大于指定年龄的学生。本人菜鸟，第一次发JAVA博客，也是第一次发博客！望大家交流指正！
ytblackbird的博客
03-17 763
今天老师让设计个学生类，用日期类来求出年龄并通过输入指定年龄求出大于年龄的学生！下面是我的小代码： package stuT_test; import java.text.SimpleDateFormat; import java.util.*; /** * 1.建立个学生类，属性有姓名，出生日期等。 * 2.建立学生数组，输入一个年龄，求出所有大于此年龄的学生。 * * @au
优雅参数判空_Java8 ： Optional 类，优雅判定null
weixin_31319319的博客
02-05 1071
Optional不是对null关键字的一种替代，而是对于null判定提供了一种更加优雅的实现NullPointException可以说是所有java程序员都遇到过的一个异常，虽然java从设计之初就力图让程序员脱离指针的苦海，但是指针确实是实际存在的，而java设计者也只能是让指针在java语言中变得更加简单、易用，而不能完全的将其剔除，所以才有了我们日常所见到的关键字null。空指针异常是一个运...
java_Stream流和Optional
beginnerdzz的博客
06-01 762
​ Java8的Stream使用的是函数式编程模式，如同它的名字一样，它可以被用来对集合或数组进行链状流式的操作。可以更方便的让我们对集合或数组操作。 idea 对debug对stream流的直观体现：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GtKTiuQX-1654088320870)(C:\Users\DONG\AppData\Roaming\Typora\typora-user-images\image-20220527225905697.png)]单列集合： 数
Java8新特性之Stream流的使用
netuser1937的博客
11-28 910
Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作，在新版的JPA中，也已经加入了Stream。 1、Stream的操作步骤 Stream有如下三个操作步骤： 一、创建Stream 从一个数据源，如集合、数组、值、文件中获取流。 //集合 //这种数据源较为常用，通过stream()方法即可获取流对象： List<Person> list = new ArrayList<Person>(); Stream<Pers
log4j2如何根据配置的配置文件选取配置文件处理类的（ConfigurationFactory源码分析）
honghailiang的专栏
10-19 6680
从上一篇（slf4j绑定log4j2日志系统的过程（源码分析）的reconfigure()方法分析 一、环境 log4j-core-2.2.jar 二、背景知识 我们知道log4j2（2.2版本）支持的配置文件类型有以下几种： XML、JSON、YAML 当然配置的实现由多种方式：官方文档中有介绍 Configuration of Log4j 2 can be accompl
JAVA教程 从入门到精通 Day19
dlogcs的博客
03-24 548
JAVA基础
java8之stream：处理集合数据
热门推荐
琦彦
04-18 2万+
Streams lambda表达式允许我们在不创建新类的情况下传递行为，从而帮助我们写出干净简洁的代码。lambda表达式是一种简单的语法结构，它通过使用函数式接口来帮助开发者简单明了的传递意图。 Stream是java8引入的一个重度使用lambda表达式的API。Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高...
Java8新特性Lambda表达式&Stream流&方法引用最全集锦
KG_181的博客
04-16 482
List bubbles = Arrays.asList(new Bubble(1), new Bubble(2), new Bubble(3)); System.out.println(bubbles.stream() .mapToInt(b -> b.i) .sum()); Set w = new HashSet<>(Arrays.asList(“It’s a wonderful day for pie!”.split(" "))); w.stream() .map(x -> x
Day01_JavaSE篇
weixin_45014721的博客
08-24 349
一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类。而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。定义：用于解释说明程序的文字Java注释的作用：在程序中，尤其是复杂的程序中，适当地加入注释可以增加程序的可读性，有利于程序的修改、调试和交流。
2021-02-08/09 大数据课程笔记 day19day20 某大型网站日志分析离线系统
qq_44745905的博客
02-10 4304
@R星校长 某大型网站日志分析离线系统 项目需求分析 概述 该部分的主要目标就是描述本次项目最终七个分析模块的界面展示。 工作流   在我们的 demo 展示中，我们使用 jquery+echarts 的方式调用程序后台提供的 rest api 接口，获取 json 数据，然后通过 jquery+css 的方式进行数据展示。工作流程如下： 分析 总述 在本次项目中我们分别从七个大的角度来进行分析，分别为： 用户基本信息分析模块 浏览器信息分析模块 地域信息分析模块 用户浏览深度分析模块 外链数据分析模块 .
记录一下java的常用单词
m0_51681861的博客
11-23 822
Java 课程系列 ———————————————————————————1Java 编程语言单词汇总 Java 研究院 版本：V 2.0 step-01 掌握 1、JDK abbr. Java 开发工具包（Java Development Kit） （abbr.缩写） 2、JRE abbr. Java 运行环境（Java Runtime Environment） 3、JVM abbr. Java 虚拟机（Java Virtual Machine） 4、system ['sɪstəm] System n.
尚硅谷JAVA基础笔记吐血整理
jiey0407的博客
06-22 1727
第1章 JAVA语言概述第2章 基本语法第3章 数组形参：方法定义时，声明的小括号内的参数实参：方法调用时，实际传递给形参的数据方法的形参传递机制：值传递如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值相同点：1、定义变量的格式：数据类型 变量名=变量值2、先声明后使用3、变量都有其作用域不同点：1、在类中声明的位置不同，属性直接定义在类的{}内，局部变量声明在方法内，方法形参，代码块内，构造器 形参、构造器内部的变量2、权限修
getClass().getClassLoader()为null
码农的幸福生活
04-13 9863
想获取resources下的文件，之前用过this.getClass().getClassLoader().getResourceAsStream(path);可以获取到，但最近的一个工程中需要在一个静态方法中获取该文件，没有了this，我直接用了Class.class.getClassLoader().getResourceAsStream(path)，结果发现返回为null。 原因：
JAVA8 - --- - Optional
weixin_30725467的博客
09-22 136
/* * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * ...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 165
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
最新发布
qq_3512323979的博客
08-26 243
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 664
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1167
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
深入探索：day15-类加载器解析
Java中的类加载器可以分为三个主要类型：引导类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）和应用程序类加载器（Application ClassLoader）。引导类加载器负责加载核心的Java类库，而...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值