JAVA学习

最新推荐文章于 2024-08-03 21:02:21 发布
最新推荐文章于 2024-08-03 21:02:21 发布
阅读量190 收藏
点赞数
文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66498478/article/details/128120912
版权

文章目录

2.面向对象

A.面向对象基础

a.设计对象

在这里插入图片描述

b.this关键字

在这里插入图片描述

3.常用算法

A.Date类

点击API文档查询
在这里插入图片描述

import java.util.Date;

public class test {
    public static void main(String[] args) {
        Date d =new Date();
        //1.输出当前时间Wed Nov 30 22:22:29 CST 2022
        System.out.println(d);
		
		//2.Date输出毫秒值
		System.out.println(d.getTime());//1669818604571
		//System输出毫秒值
		System.out.println(System.currentTimeMillis());//1669818604598
        					
    }
}

在这里插入图片描述

import java.util.Date;

public class test {
    public static void main(String[] args) {
	//1.获取时间毫秒值
        long time1 = System.currentTimeMillis();  
        time1 += (60*60+121)*1000;     	//获得1个小时121秒后的时间
        Date d =new Date(time1);    	//将时间毫秒值转化为具体时间
        System.out.println(d);
        
	//2.settime
	    time1 += (60*60+121)*1000;
        d.setTime(time1);		//设置当前毫秒值的时间
        System.out.println(d);
    }
}

Date类总结
在这里插入图片描述

B.SimpleDateFormate类(简单日期格式化)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import java.text.SimpleDateFormat;
import java.util.Date;

public class test {
    public static void main(String[] args) {
        Date d =new Date();
        System.out.println(d);//Wed Nov 30 23:03:20 CST 2022
		
		//具体时间转格式化
        SimpleDateFormat sp = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");//无参数默认为2022/11/30 23:04
        System.out.println(sp.format(d));//2022年11月30日 23:11:637 周三 下午
        
		//毫秒值转格式化
	    long ms1 =System.currentTimeMillis();
        System.out.println(sp.format(ms1));
    }
}

在这里插入图片描述

import java.text.ParseException;
import java.text.SimpleDateFormat;

public class test {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat d = new SimpleDateFormat("yyyy年MM月dd日 HH:MM:SS EEE a");
        //将字符串转换为日期对象，上下格式需相同
        System.out.println(d.parse("2022年11月30日 23:11:637 周三 下午"));//Wed Nov 30 23:00:00 CST 2022

    }
}

SimpleDateFormate类的总结
在这里插入图片描述

C.Calendar类C

在这里插入图片描述
在这里插入图片描述

import java.util.Calendar;

public class test {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.get(Calendar.YEAR));//输出年2022
        System.out.println(cal.get(Calendar.MONTH)+1);//输出月12
        System.out.println(cal.get(Calendar.DAY_OF_MONTH));//输出日1
    }
}

D.新增日期类

在这里插入图片描述

E.包装类

在这里插入图片描述

在这里插入图片描述

  • 自动拆箱：包装类 可以赋值给 基本类型
  • 自动装箱：基本类型 可以赋值给 包装类
    在这里插入图片描述
public class test {
    public static void main(String[] args) {
        String number ="23";
        int age = Integer.parseInt(number);	//转换成int型
        System.out.println(age+1);//24
    }
}

F.正则表达式

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

System.out.println("123a".matches("\\w{4,15}"));//true

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        phone();
        email();
    }
//1.手机验证
    public static void phone(){
    //输入手机号
        Scanner s = new Scanner(System.in);
        System.out.println("请输入您的手机号");
        String phone = s.next();
        
    //正则表达式判断，第一位为1，第二位为3-9，第三到九为数字
        if(phone.matches("[1][3-9]\\d{9}")){	
            System.out.println("手机号验证成功");
        }else{
            System.out.println("输入有误，请重新输入");
        }
    }
//2.邮箱验证
    public static void email(){
    //输入
        Scanner s = new Scanner(System.in);
        System.out.println("请输入您的邮箱号");
        String phone = s.next();
    //判断邮箱
        if(phone.matches("\\w{1,30}@[a-zA-z0-9]{0,30}(\\.[a-zA-z]{1,30}){1,2}")){
            System.out.println("邮箱验证成功");
        }else{
            System.out.println("输入有误，请重新输入");
        }
    }
}
  • 正则表示式在字符串方法中的使用
    在这里插入图片描述
public class test {
    public static void main(String[] args) {
        String name ="我qqqq叫wwwww张eeee三";
        String[] arr = name.split("\\w+");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//我叫张三
        }

        String name2 = name.replaceAll("\\w+"," ");
        System.out.println(name2);	//我叫张三
    }
}

G.Arrays

在这里插入图片描述

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arr ={10,2,3,4,20,30,1};
        System.out.println(Arrays.toString(arr));//输出数组，[10, 2, 3, 4, 20, 30, 1]

        Arrays.sort(arr);	//排序，[1, 2, 3, 4, 10, 20, 30]
        System.out.println(Arrays.toString(arr));

        int judge = Arrays.binarySearch(arr,15);//二分查找，-6
        System.out.println(judge);
    }
}
  • 自定义排序规则
    在这里插入图片描述

在这里插入图片描述

import java.util.Arrays;
import java.util.Comparator;

public class test {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 4, 20, 30, 1};	//Interger
	//降序排序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {	
                return o2 - o1;	//降序，顺序为o1-o2
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}
  • 二分查找
    Arrays.binarySearch()
import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arr = {10, 2, 3, 4, 20, 30, 1};
        //二分查找
        System.out.println(Arrays.binarySearch(arr,2));//1
    }

}

H.Lambda表达式

在这里插入图片描述

  • 1.正常重写
public class test {
    public static void main(String[] args) {
    //1.正常重写
        Swimming s1 =new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳");
            }
        };
    //调用方法
        go(s1);
    }

    private static void go(Swimming s) {
        System.out.println("成功");
        s.swim();

    }


}
interface  Swimming{
    void swim();
}
  • 2.lambda重写
public class test {
    public static void main(String[] args) {
    //2.lambda重写和调用
        go(()->{
            System.out.println("游泳");
        });
    }

    private static void go(Swimming s) {
        System.out.println("成功");
        s.swim();

    }


}
//Lambda接口只能又一个抽象方法
interface  Swimming{
    void swim();
}

降序排序的简化

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 4, 20, 30, 1};	//Interger
        //lambda表达式
        Arrays.sort(arr, (Integer o1, Integer o2)-> {
                return o2 - o1;	//降序，顺序为o1-o2
        });
        System.out.println(Arrays.toString(arr));
    }
}
  • Lambda的进一步简化
import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        Integer[] arr = {10, 2, 3, 4, 20, 30, 1};	//Interger
        //1.省略类型    //降序排序
        Arrays.sort(arr, (o1, o2)-> {
                return o2 - o1;	//降序，顺序为o1-o2
        });
        System.out.println(Arrays.toString(arr));

        //2.只有一个参数省略括号
        sum1(a->{
            return a+a;
        });
        //3.只有一条语句时，可省略大括号{}分号;
        ride1(a-> System.out.println(a*a));

        //4.只有一条return语句时，省略return大括号分号; 
        sum1(a->a+a);
    }
    public static void sum1(Math1 s){
        System.out.println("加法计算完成");
        System.out.println(s.sum(5));
    }
    public static void ride1(Math2 s){
        System.out.println("乘法计算完成");
        s.ride(5);
    }
}

//接口
interface Math1{
    int sum(int a);
}
interface Math2{
    void ride(int a);
}

在这里插入图片描述

  • 简化拓展
//当输出与输入参数相同时，可简化
//1.
ride1(a-> System.out.println(a));
可简化为
ride1(System.out::println);

//2.当对象的输出与输入参数相同时
ride1(s -> new Student(s));
//可简写为 
ride1(Student::new);

E.String

在这里插入图片描述

在这里插入图片描述

import java.util.Random;
import java.util.Scanner;

public class test4 {
    public static void main(String[] args) {
        //1.生成验证码
        String code = y();
        //2.输入验证码
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入");
        String user1 = scanner.next();
        //3.比较验证码是否正确（无视大小写）
        if (user1.equalsIgnoreCase(code)){
            System.out.println("验证成功");
        }else {
            System.out.println("验证失败");
        }
    }
    //生成随机验证码
    public static String y(){
        String number = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
        String code = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            int j = r.nextInt(number.length());
            char c = number.charAt(j);
            code += c;
        }
        System.out.println("\n"+code);
        return code;
    }
}

在这里插入图片描述


public class phone {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String number = " ";
        System.out.println("请输入手机号码");
        for (int i = 0; i < 100; i++) {
            //1.输入手机号，并判断是否是11位
            number = sc.next();
            if(number.length()==11)break;
            System.out.println("请重新输入");
        }
            //2.截取前三位
        String q3 = number.substring(0,3);
            //3.截取第八位到结束
        String h4 = number.substring(7);
        number = q3 + "****"+h4;
        System.out.println("中奖号码：\n"+number);//123****8912
    }
}

4.深入泛型

在这里插入图片描述
在这里插入图片描述

A.泛型类

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        Movie<String> movie = new Movie<>();
        movie.add("张三",18);
        System.out.println(movie.name+movie.age);//张三18
    }
}

class Movie<E>{
    public E name;
    public int age;
    public void add(E e,int a){
        this.name = e;
        this.age = a;
    }
}

总结在这里插入图片描述

B.泛型方法

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        String[] names={"张三","李四","王五"};
        Integer[] ages={10,20,30};
        print(ages);
}
//定义泛型方法，和泛型参数
    public static <T> void print(T[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]);
        }
    
    }
}

C.泛型接口

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        NewMovie n = new NewMovie();
        n.addName("战狼" );
        n.addId(10);
        System.out.println(n.name);
        System.out.println(n.id);
    }
}

//继承接口，声明泛型的类型
class NewMovie implements Movie<String> {
    String name;
    int id;



    @Override
    public void addName(String name) {
        this.name = name;
    }

    @Override
    public void addId(int i) {
        this.id = i;
    }
}

//定义泛型接口
interface Movie<E>{	
     void addName(E e);
     void addId(int i);
}

D.通配符和上下限

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

5.集合

集合和数组都是容器

  • 数组定义完成并启动后，类型，长度固定
  • 集合的大小不固定，启动后可以动态变化，类型可不固定

在这里插入图片描述
集合的体系
在这里插入图片描述

A.collection集合

在这里插入图片描述

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class test {
    public static void main(String[] args) {
    //ArrayList
        Collection al1 = new ArrayList();
        al1.add(10);
        al1.add(10);
        al1.add("hello");
        al1.add(11.2);
        al1.add("hello");
        System.out.println(al1);
	//HashSet
        Collection al2 = new HashSet();
        al2.add(10);
        al2.add(10);
        al2.add("hello");
        al2.add(11.2);
        al2.add("hello");
        System.out.println(al2);
    }
}

在这里插入图片描述

a.集合对于泛型的支持

在这里插入图片描述

        Collection <String>al2 = new HashSet();//添加String泛型
        al2.add(10);	//报错
        al2.add(10);	//报错
        al2.add("hello");
        al2.add("hello");
        System.out.println(al2);

b.集合的方法

点击查询collection集合API

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

public class test {
    public static void main(String[] args) {
        Collection a = new ArrayList();
        //1.添加集合
        a.add(10);
        a.add(10);
        a.add("hello");
        System.out.println(a);

        //2.清空集合
        //al1.clear();

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

        //4.获取集合大小
        System.out.println(a.size());

        //5.判断是否包含元素
        System.out.println(a.contains("hello"));//true
        System.out.println(a.contains("HELLO"));//false
        
//分割线
        System.out.println("6:==============");

        //6.删除元素：多个重复默认删除第一个
        System.out.println(a.remove(10));
        System.out.println(a);

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

        //8.合并集合
        Collection<String> b1 =new ArrayList<>();
        Collection<String> b2 =new ArrayList<>();
        b1.add("hello");
        b2.add("你好");
        b1.addAll(b2);
        System.out.println("b1:"+b1);
        System.out.println("b2"+b2);
    }
}

在这里插入图片描述

c.集合迭代器 Iterator

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Collection a = new ArrayList();
        //1.添加集合
        a.add("张三");
        a.add("李四");
        a.add("王五");
        a.add("老六");
        System.out.println(a);
        
	//使用迭代器遍历Iterator
        Iterator<String> iter = a.iterator();
        while (iter.hasNext()){		//判断当前位置是否有元素,否则可能越界
            String ele = iter.next();//获取元素并移到下一个位置 //默认索引0
            System.out.println(ele);
        }

    }
}

在这里插入图片描述

d.增强版for循环

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Collection<String> a = new ArrayList();
        //1.添加集合
        a.add("张三");
        a.add("李四");
        a.add("王五");
        a.add("老六");
        System.out.println(a);
	//1.遍历集合
        for(String ele : a){
            System.out.println(ele);
        }
	//2.遍历数组
        double[] scores = {100，60,59};
        for (double score : scores) {
            if(score < 60){
                score = 60;
            }
            System.out.println(score);// 100，60，60 //不改变原数组
        }
        System.out.println(Arrays.toString(scores));//[100,60,59]

    }
}

在这里插入图片描述

e.集合+Lambda表达式(foreach)

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Collection<String> alist = new ArrayList();
        //1.添加集合
        alist.add("张三");
        alist.add("李四");
        alist.add("王五");
        alist.add("老六");
        System.out.println(alist);//[张三, 李四, 王五, 老六]
        
   //1.正常foreach遍历     
        alist.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        
    //2.lambda简写  
        alist.forEach(s -> System.out.println(s));

    }
}

f.集合存储对象

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

public class test {
    public static void main(String[] args) {
    //自定义Movie类型集合
        Collection<Movie> movies = new ArrayList<>();
        movies.add(new Movie("战狼",95));
        movies.add(new Movie("流浪地球",98));
        //遍历对象
        for (Movie movie : movies) {
            System.out.print("片名："+movie.name);
            System.out.println(movie.score+"分");
        }
        System.out.println(movies);//输出地址
    }
}
//定义电影类
class Movie{
    public String name;
    public double score;

    public Movie() {
    }
    public Movie(String name, double score) {
        this.name = name;
        this.score = score;
    }
}

在这里插入图片描述

(1)List

在这里插入图片描述

a.List的独有方法

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        //1.List：有序，可重复，有索引
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("hello");
        list.add("你好");
        System.out.println(list);		//[hello, hello, 你好]

        //2.在某个位置插入元素
        list.add(2,"world");
        System.out.println(list);		//[hello, hello, world, 你好]

        //3.根据索引删除元素，返回删除元素
        System.out.println(list.remove(2));//world
        System.out.println(list);			//[hello, hello, 你好]

        //4.根据索引获取元素
        System.out.println(list.get(2));	//你好

        //5.修改索引位置处的元素
        System.out.println(list.set(0,"hi"));//hello
        System.out.println(list);			//[hi, hello, 你好]

    }
}

b.List的遍历

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        //List：有序，可重复，有索引
        List<String> lists = new ArrayList<>();
        lists.add("hello");
        lists.add("hello");
        lists.add("你好");
        System.out.println(lists);		//[hello, hello, 你好]

        //1.for循环
        for (int i = 0; i < lists.size(); i++) {
            System.out.println("1："+lists.get(i));
        }

        //2.迭代器
        Iterator<String> it = lists.iterator();
        while (it.hasNext()){
            System.out.println("2："+it.next());
        }

        //3.for遍历对象
        for (String list : lists) {
            System.out.println("3："+list);
        }
      	//4.forEach
        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("4:"+s);
            }
        });

        //5.Lambda
        lists.forEach(s-> System.out.println("5："+s));


    }
}

c.LinkedList独有方法

特点：底层结构是双链表（可以完成栈和队列），查询慢，首尾操作速度快，多以多了很多首位操作的特有API

在这里插入图片描述

import java.util.LinkedList;

public class test {
    public static void main(String[] args) {
      //1.栈，先进后出
        LinkedList<String> zhan = new LinkedList<>();
       	//添加
        zhan.addFirst("1");		//可改为zhan.push("1");
        zhan.addFirst("2");
        zhan.addFirst("3");
        System.out.println(zhan);//[3, 2, 1]
        //移除
        zhan.removeFirst();		//可改为zhan.pop();
        zhan.removeFirst();
        System.out.println(zhan);//[1]

      //2.队列：先进先出
        LinkedList<String> dui = new LinkedList<>();
        //添加
        dui.addLast("1");
        dui.addLast("2");
        dui.addLast("3");
        System.out.println(dui);//[1, 2, 3]
        //移除
        dui.removeFirst();
        dui.removeFirst();
        System.out.println(dui);//[3]
    }
}

d.集合并发修改异常

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        //1.栈，先进后出
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("hello");
        list.add("你好");
        System.out.println(list);
        //1.迭代器遍历删除
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String ele = it.next();
            if("hello".equals(ele)){
                //list.remove("hello");//集合报异常，使用迭代器删除
                it.remove();//删除当前所在元素，且不会后移
            }
        }
        System.out.println(list);
        //2.foreach遍历删除
//        for (String s : list) {
//            if("hello".equals(s)){
//                list.remove("hello");//报异常
//            }
//        }

        //3.Lambda
//        list.forEach(s->{if("hello".equals(s)){
//                list.remove("hello");//报异常
//            }});
        //4.for循环
//        for (int i = 0; i < list.size(); i++) {
//                        String ele = list.get(i);
//            if("hello".equals(ele)){
//                list.remove("hello");//不会报错，但是会漏删
//            }
//        }
//        System.out.println(list);//[hello, 你好]

        //4.for循环,解决方法1
//                for (int i = list.size()-1; i >=0; i--) {
//                        String ele = list.get(i);
//            if("hello".equals(ele)){
//                list.remove("hello");
//            }
//        }
//        System.out.println(list);//[你好]
       // 4.2for循环,解决方法2
//        for (int i = 0; i < list.size(); i++) {
//                        String ele = list.get(i);
//            if("hello".equals(ele)){
//                list.remove("hello");
//                i--;
//            }
//        }
//        System.out.println(list);//[你好]
    }
}

(2)Set

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
    //w无序，不重复，无索引
        Set<String> sets = new HashSet<>();
        sets.add("hello");
        sets.add("hello");
        sets.add("hi");
        sets.add("你好");
        sets.add("你好");
        System.out.println(sets);//[hi, 你好, hello]
    }
}

a.HashSet

  • 哈希值

是JDK根据对象的地址，按照某种规则算出来的int类型的数值

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        String name = "张三";
        //获取Hash值
        System.out.println(name.hashCode());//774889
        System.out.println(name.hashCode());//774889,同一个对象相同
		
        String sex = "男";
        System.out.println(sex.hashCode());//30007
    }
}
  • HashSet底层原理
  • HashSet集合底层采取 哈希表存储的数据
  • 哈希表是一种对于增删改查数据性能都较好的结构

在这里插入图片描述
在这里插入图片描述

  • 两个对象，set集合去重复
    在这里插入图片描述

b.LinkedHashSet

在这里插入图片描述

c.Treeset

在这里插入图片描述

  • 自定义规则的方式
    在这里插入图片描述
  • 方式一
import java.util.Set;
import java.util.TreeSet;

public class test {
    public static void main(String[] args) {
    //定义集合
        Set<Student> sets = new TreeSet<>();
        sets.add(new Student(1,"张三"));
        sets.add(new Student(1,"张三"));
        sets.add(new Student(2,"李四"));
        sets.add(new Student(3,"王五"));
      //输出集合内容，去重复按自定义规则排序
        for (Student set : sets) {
            System.out.println(set.id);
            System.out.println(set.name);
        }

    }
}

class Student implements Comparable<Student>{
    public int id;
    public String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
	//自定义规则方法一
    @Override
    public int compareTo(Student o) {
        return this.id-o.id;//id升序排序
    }
}
  • 方式二
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class test {
    public static void main(String[] args) {
    //自定义规则方法二
    //Lambda简写：
    //Set<Student> sets = new TreeSet<>((o1,o2)->  o1.id - o2.id);
        Set<Student> sets = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.id - o2.id;
            }
        });
        sets.add(new Student(1,"张三"));
        sets.add(new Student(1,"张三"));
        sets.add(new Student(2,"李四"));
        sets.add(new Student(3,"王五"));
     输出集合内容，去重复按自定义规则排序
        for (Student set : sets) {
            System.out.println(set.id);
            System.out.println(set.name);
        }

    }
}

class Student {
    public int id;
    public String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }


}
  • 排序规则
    在这里插入图片描述

拓展1:可变参数

在这里插入图片描述

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        System.out.println("元素长度："+sum(1));     //1
        System.out.println("元素长度："+sum(1,2));   //2
        System.out.println("元素长度："+sum(1,2,3)); //3
        System.out.println("元素长度："+sum(1,2,3,4));//4
    }

    public static int sum(int...nums) {
        System.out.println("元素内容"+Arrays.toString(nums));
        return nums.length;
    }
}

在这里插入图片描述

拓展2：collections集合工具类

在这里插入图片描述

  • 常用API

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
      //1.给对象批量添加元素 
        Collections.addAll(lists,"hello","hi","你好");
        System.out.println(lists);//[hello, hi, 你好]

      //2.打乱List集合的顺序，注：set无法打乱
        Collections.shuffle(lists);
        System.out.println(lists);//[hello, 你好, hi]

      //3.Collections对List集合排序
         List<Integer>scores = new ArrayList<>();
         //添加元素
         Collections.addAll(scores,99,88,100,77,66);
        System.out.println(scores);//[99, 88, 100, 77, 66]
        //sort方法排序
        Collections.sort(scores);
        System.out.println(scores);//[66, 77, 88, 99, 100]
    }
}

在这里插入图片描述

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

public class test {
//List的自定义排序 方法一
    public static void main(String[] args) {
        List<Student> lists = new ArrayList<>();
        lists.add(new Student(1,"张三"));
        lists.add(new Student(1,"张三"));
        lists.add(new Student(2,"李四"));
        lists.add(new Student(3,"王五"));
        输出集合内容，保留重复按自定义规则排序
        for (Student list : lists) {
            System.out.print(list.id+":");
            System.out.print(list.name+"   ");//1:张三   1:张三   2:李四   3:王五   
        }

    }
}

class Student implements Comparable<Student>{
    public int id;
    public String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }


    @Override
    public int compareTo(Student o) {
        return this.id - o.id;
    }
}

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

public class test {
    public static void main(String[] args) {
    //自定义排序方法二
        List<Student> lists = new ArrayList<>();
        lists.add(new Student(1,"张三"));
        lists.add(new Student(1,"张三"));
        lists.add(new Student(2,"李四"));
        lists.add(new Student(3,"王五"));
        
        //sort自带比较器对象
        Collections.sort(lists,(o1,o2)->  o1.id - o2.id);
        
        输出集合内容，保留重复按自定义规则排序
        for (Student list : lists) {
            System.out.print(list.id+":");
            System.out.print(list.name+"   ");//1:张三   1:张三   2:李四   3:王五 
        }

    }
}

class Student {
    public int id;
    public String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }


}

B.Map集合

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 使用最多的Map集合是HashMap
  • 重点掌握HashMap，LinkedHashMap，TreeMap
  • Map集合体系特点
    在这里插入图片描述
    在这里插入图片描述
import java.util.HashMap;
import java.util.Map;

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
       	//1.添加元素：无序，不重复，无索引
        maps.put("咖啡",15);
        maps.put("奶茶",10);
        maps.put("茶",20);
        System.out.println(maps);//{咖啡=15, 茶=20, 奶茶=10}
    }
}

a.Map常用方法

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        //put()
        maps.put("咖啡",15);
        maps.put("奶茶",10);
        maps.put("茶",20);
        System.out.println(maps);
    //2.清空集合clear()
        //maps.clear();
        //System.out.println(maps);

    //3.判断集合是否为空，为空返回true
        //isEmpty()
        System.out.println(maps.isEmpty());//false

    //4.获取键值对的值
        //get()
        Integer i = maps.get("奶茶");
        System.out.println(i);//10

    //5.根据键删除值
        //remove()
        System.out.println(maps.remove("茶"));//20，返回值
        System.out.println(maps);  //{咖啡=15, 奶茶=10}


        System.out.println("6===========================");

    //6.containsKey("")判断是否包含某个键，包含true
        //containsKey("")
        System.out.println(maps.containsKey("奶茶"));//true
        
    //7.判断是否包含某个值，包含true
        //containsValue()
        System.out.println(maps.containsValue(15));//true
        
    //8.获取全部键的集合
        //keySet()
        Set<String> keys = maps.keySet();
        System.out.println(keys);//[咖啡, 奶茶]
        
   //9.获取全部值的集合
        //values()
        Collection<Integer> values = maps.values();
        System.out.println(values);//[15, 10]
        
    // 10.集合的大小
        //size()
        System.out.println(maps.size());//2


        System.out.println("11==========================");

    //11.合并其他Map集合
        //putAll()
        Map<String, Integer> books1 = new HashMap<>();
        books1.put("月亮与六便士",10);
        books1.put("福尔摩斯",20);
        books1.put("语文",15);
        Map<String, Integer> books2 = new HashMap<>();
        books2.put("语文",100);
        books2.put("数学",30);
        books2.put("英语",30);
        books1.putAll(books2);
        System.out.println(books1);//{月亮与六便士=10, 福尔摩斯=20, 数学=30, 语文=100, 英语=30}//键相同，后面覆盖前面
        System.out.println(books2);//{数学=30, 语文=100, 英语=30}

    }
}

b.Map遍历–键找值

在这里插入图片描述
在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{oppo=4999, 华为=5500, 小米=2999, 三星=3999}

    //2.键找值遍历
    	//获取全部键
        Set<String> goods = maps.keySet();
        //遍历
        for (String good : goods) {
            int value = maps.get(good);
            System.out.print(good+value+"元   ");//oppo4999元   华为5500元   小米2999元   三星3999元
        }

    }
}

c.Map遍历–值键对

在这里插入图片描述
在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{oppo=4999, 华为=5500, 小米=2999, 三星=3999}

    //2.值找键遍历
        //将Map转换为Set集合    //maps.entrySet();
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        //遍历
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value= entry.getValue();
            System.out.print(key + value +"元    ");//oppo4999元    华为5500元    小米2999元    三星3999元
        }


    }
}

d.forEach遍历

1111

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{oppo=4999, 华为=5500, 小米=2999, 三星=3999}

    //2.forEach遍历
        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String key, Integer value) {
                System.out.print(key + value +"元    ");//oppo4999元    华为5500元    小米2999元    三星3999元    
            }
        });


    }
}

E.Lambda遍历

1111

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

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{oppo=4999, 华为=5500, 小米=2999, 三星=3999}

    //2.Lambda遍历
        maps.forEach((key,value)-> System.out.print(key + value +"元    "));
        //oppo4999元    华为5500元    小米2999元    三星3999元);
    }
}

(1)HashMap

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{oppo=4999, 华为=5500, 小米=2999, 三星=3999}



    }
}

(2)LinkedHashMap

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        Map<String,Integer> maps = new LinkedHashMap<>();
    //1.添加元素：无序，不重复，无索引
        maps.put("华为",5500);
        maps.put("华为",5500);
        maps.put("小米",2999);
        maps.put("三星",3999);
        maps.put("oppo",4999);
        System.out.println(maps);//{华为=5500, 小米=2999, 三星=3999, oppo=4999}
    }
}

(3)TreeStet

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
    //1.创建TreeMap集合
        Map<Integer, String> maps = new TreeMap<>();
        //添加元素
        maps.put(1,"张三");
        maps.put(2,"李四");
        maps.put(3,"王五");
        maps.put(3,"王五");
        maps.put(4,"老六");
        //输出元素
        System.out.println(maps );//{1=张三, 2=李四, 3=王五, 4=老六}

	//2.创建TreeMap对象集合
        Map<Student,String> students = new TreeMap<>();
        //添加元素
        students.put(new Student(1,"小明","18"),"广东");
        students.put(new Student(2,"小红","20"),"江苏");
        students.put(new Student(3,"小刚","21"),"福建");
        //Lambda表达式遍历    //使用比较器排序
        students.forEach((key,value)-> System.out.println("学号："+key.getId()+"   地区："+ value));
        //学号：1   地区：广东   学号：2   地区：江苏   学号：3   地区：福建   
    }
}

class Student implements Comparable<Student>{
    private int id;
    private String name;
    private String age;

    public Student() {
    }

    public Student(int id, String name, String age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    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 String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
//比较器排序
    @Override
    public int compareTo(Student o) {
        return this.id - o.id ;
    }
}

C.集合的嵌套

  • 投票系统案例
import java.util.*;

public class test {
    public static void main(String[] args) {
        //集合的嵌套，Mao中包含List（也可以是数组）
        Map<String, List<String>> maps = new HashMap<>();
        //创建List集合
        List<String>  selects1= new ArrayList<>();
        //添加元素，投票想去的地点A和c
        Collections.addAll(selects1,"A","C");
        maps.put("小明",selects1);
        System.out.println(maps);//{小明=[A, C]}

        //创建3个元素
        List<String>  selects3= new ArrayList<>();
        List<String>  selects4= new ArrayList<>();
        List<String>  selects5= new ArrayList<>();
        Collections.addAll(selects3,"B","C");
        Collections.addAll(selects4,"A","B","C");
        Collections.addAll(selects5,"A","D");
        maps.put("张三",selects3);
        maps.put("李四",selects4);
        maps.put("王五",selects5);
        //输出每个人的选择情况
        System.out.println(maps);//{李四=[A, B, C], 张三=[B, C], 小明=[A, C], 王五=[A, D]}


        //统计地点投票情况
        Map<String, Integer>  allSelect = new HashMap<>();
        //定义一个存List的集合
        Collection<List<String>> values = maps.values();

        System.out.println(values);//[[A, B, C], [B, C], [A, C], [A, D]]

        for (List<String> value : values) {

            System.out.print(value+"---");//[A, B, C]---[B, C]---[A, C]---[A, D]---

            for (String v : value) {
                if (allSelect.containsKey(v)){          //判断是否有该类型的票
                    allSelect.put(v,allSelect.get(v)+1);  //allSelect.get(v)获取键的值
                }else {
                    allSelect.put(v,1);        //如果没有，就初始化为1
                }
            }
        }
        
        //输出投票结果
        System.out.println(allSelect);//{A=3, B=2, C=3, D=1}
    }
}

D.不可变集合对象

  • 不可变集合的创建
    在这里插入图片描述
import java.util.List;

public class test {
    public static void main(String[] args) {
    //1.不可变的List集合List.of()
        List<String> lists = List.of("你好","hello","hi");
        // lists.set(1,"say"); //报错，不可改变
        // lists.add("你还好吗");//报错
        String list = lists.get(1);
        System.out.println(list);
        
	//2.不可变的Set集合set.of()
		 Set<String> names = Set.of("小明","小刚","小红");
        // names.add("小王"); //报错
        System.out.println(names);//[小红, 小刚, 小明]
        
	//3.不可变的Map集合Map.of()
        Map<Integer,String> maps = Map.of(1,"语文",2,"数学",3,"英语");
        // maps.put(4,"物理");    //报错
        System.out.println(maps);	//{1=语文, 2=数学, 3=英语}
    }
}

6.Stream流

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
    //定义List集合
        List<String> names =  new ArrayList<>();
    //添加元素
        Collections.addAll(names,"张三","李四","张一三","","张二三");
    //stream1.先找出姓张，2.再找出名字为3个字的人，3.输出	
    //支持链式编程
		 names.stream().filter(s -> s.startsWith("张")).filter(s -> (s.length()== 3)).forEach(s -> System.out.println(s));
		 //张一三   张二三
    }
}

A.Stream流的获取

  • 集合的Stream流
    在这里插入图片描述
import java.util.*;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
    //1.List获取流
        //添加元素：有序，可重复，有索引
        List<String> names =  new ArrayList<>();
        Collections.addAll(names,"小明","小红","小刚","小强");
        //Stream流的创建
        Stream<String> stream1 = names.stream();
        Stream的输出
        stream1.forEach(s -> System.out.print(s + " "));    //小明 小红 小刚 小强

    //2.Set获取流
        //添加元素：无序，不重复，无索引
        Set<Integer> ages = new HashSet<>();
        Collections.addAll(ages,10,12,13,12,10);
        //Stream流的创建
        Stream<Integer> stream2 = ages.stream();
        //Stream的输出
        stream2.forEach(s-> System.out.print(s + " "));//10 12 13

    //3.Map获取流
        //添加元素：无序，不重复，无索引
        Map<Integer, String> maps = new HashMap<>();
        maps.put(1,"广东");
        maps.put(2,"江苏");
        maps.put(3,"浙江");
        maps.put(4,"福建");
        //获取maps的键
        Stream<Integer> stream3 = maps.keySet().stream();//1 2 3 4
        //获取maps的值
        Stream<String> stream4 = maps.values().stream();//广东 江苏 浙江 福建
        //获取maps的键值对
        Stream<Map.Entry<Integer, String>> stream5 = maps.entrySet().stream();
    }
}
  • 数组获取Stream流
    在这里插入图片描述
import java.util.Arrays;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
    //定义数组
        String[] names = {"小明","小红","小刚","小强"};
        Stream<String> stream1 = Arrays.stream(names);
   //获取当前数组的Stream流
        stream1.forEach(s-> System.out.print(s + " "));//小明 小红 小刚 小强
    //获取当前数组的Stream流
        Stream<String> names1 = Stream.of(names);
        names1.forEach(s -> System.out.print(s + " "));//小明 小红 小刚 小强
    }
}

B.Stream的常用API

在这里插入图片描述

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
    //创建集合
        List<String> names =  new ArrayList<>();
        Collections.addAll(names,"小明","小红","李刚","张强");
     //1.filter()用流对数据进行过滤 
     //找出“小”开头的人名
        Stream<String> xiao = names.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("小");
            }
        });
        可替换为Lambda
        //Stream<String> xiao = names.stream().filter(s->s.startsWith("小"));

     //forEach遍历

               xiao.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });//小明 小红
        
	//可替换为Lambda
	//xiao.forEach(s->System.out.println(s));
	//Lambda中，当输入参数与输出参数一样可简化
	//xiao.forEach(System.out::println);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
        List<String> names =  new ArrayList<>();
        Collections.addAll(names,"小明","小红","李刚","张强","小小","小刚");
        Stream<String> xiao = names.stream().filter(s -> s.startsWith("小"));
        names.stream();
        //1.limit(2)输出前两个
        xiao.limit(2).forEach(System.out::println);//小明 小红
        System.out.println("======");
        //2.skip(1)跳过一个，后输出
        // xiao.skip(1).forEach(System.out::println);小红 小小 小刚

        //3.map加工方法
        Stream<String> stringStream = names.stream().map(new Function<String, String>() {     //<加工前类型, 加工后类型>
            @Override
            public String apply(String s) {
                return "姓名：" + s;
            }
        });
        stringStream.forEach(System.out::println);//姓名：小明 姓名：小红 ......

        //3.1 Lambda表达式
         names.stream().map(s -> "lambda:"+s).forEach(System.out::println);//lambda:小明 lambda:小红 ......

         //3.2 map加工成对象
        //names.stream().map(s -> new Student(s)).forEach(System.out::println);
        names.stream().map(Student::new).forEach(System.out::println);//对象姓名：小明 对象姓名：小红 ......

        //4.Stream.of()创建Stream流
        Stream<String> s2 = Stream.of("java","c++");
        Stream<String> s1 = Stream.of("数据结构","数据库");

        5.concat(s1, s2)合并
        Stream<String> s3 = Stream.concat(s1, s2);
        s3.forEach(System.out::print);//数据结构 数据库 java c++


    }
}
class Student{


    private String name;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return "对象姓名："+ name ;
    }
}

C.Stream的终结方法

注意：终结操作方法，调用完成后流就无法继续使用了，原因是不会返回Stream了

在这里插入图片描述

7.异常

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

A.异常示例

在这里插入图片描述

package com.test.test;


public class test {
    public static void main(String[] args) {
    //1.数组索引越界问题
        int[] arr = {1,2,3};
        //System.out.println(arr[3]);//报异常，索引越界

    //2.空指针异常
        String name = null;
        System.out.println(name);//null
        //System.out.println(name.length());//报异常

    //3.类型转换异常
        Object o = 23;
        //String s = (String) o;//报异常

    //4.数字操作异常
        //int c =10/0;//报异常
        
    //5.数字转换异常
        String number = "23abc";
       // Integer it = Integer.valueOf(number);//报异常
       // System.out.println(it);
    }
}

B.异常的处理

在这里插入图片描述
在这里插入图片描述

ctrl + alt + T快速生成try…catch…

在这里插入图片描述

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        //try...catch处理异常
        try {
            System.out.println("请输入合法价格");
            String priceStr = s.nextLine();
            Double price = Double.valueOf(priceStr);//当输入非数字时报异常
            if (price > 0){		//判断价格是否大于0
                System.out.println("定价："+price);
            }else {
                System.out.println("价格必须大于0");
            }
        } catch (NumberFormatException e) {
            System.out.println("请输入合法价格");//报异常时输出
        }
    }
}

C.自定义异常

在这里插入图片描述

  • 编译时异常
public class test {
    public static void main(String[] args) {
    //编译时异常，没有try...catch会提示
        try {
            checkAge(-34);//报异常
        } catch (Error e) {
            e.printStackTrace();//打印异常信息
        }
    }
    //定义方法
    public static void checkAge(int age) throws Error {
        if (age<0||age>200){
            //throw：在方法内部直接创建一个一个异常对象，并从此点抛出
            //throws：用在方法声明上，抛出内部异常
            throw new Error(age+"不合法，请重新输入");
        }else {
            System.out.println("输入成功");
        }
    }
}

//自定义编译时异常，extends Exception
public class Error extends Exception{
    public Error() {
    }

    public Error(String message) {
        super(message);
    }
}

在这里插入图片描述

在这里插入图片描述

public class test {
    public static void main(String[] args) {
    //运行时异常，没有try...catch不会提示
        try {
            checkAge(-34);
        } catch (RuntimeError e) {
            e.printStackTrace();
        }
    }
    public static void checkAge(int age){
        if (age<0||age>200){
            //throw：在方法内部直接创建一个一个异常对象，并从此点抛出
            //throws：用在方法声明上，抛出内部异常
            throw new RuntimeError(age+"不合法，请重新输入");
        }else {
            System.out.println("输入成功");
        }
    }
}

自定义运行时异常，extends RuntimeException
public class RuntimeError extends RuntimeException{
    public RuntimeError() {
    }

    public RuntimeError(String message) {
        super(message);
    }
}

D.finally

在这里插入图片描述

8.日志

在这里插入图片描述
在这里插入图片描述

A.Logback

点击进入Logback官网

在这里插入图片描述
在这里插入图片描述

  • 日志级别

在这里插入图片描述

在这里插入图片描述

9.File

在这里插入图片描述

  • file类定位文件以及操作文件本身
  • io流读写文件数据

A.file类的常见方法

import java.io.File;
import java.text.SimpleDateFormat;

public class filetest {
    public static void main(String[] args) {
        File f1 = new File("src/com/test/file/img1.jpg");
        //1.获取绝对路径
        System.out.println(f1.getAbsolutePath());//C:\Users\hfq20\IdeaProjects\javastudy\src\com\test\file\img1.jpg
        //2.获取定义使用路径
        System.out.println(f1.getPath());//src\com\test\file\img1.jpg
        //3.获取文件名
        System.out.println(f1.getName());//img1.jpg
        //4.获取字节大小
        System.out.println(f1.length());//16354
        //5.获取文件最后修改时间
        System.out.println(f1.lastModified());//1672559319356
              //时间格式化
        long ftime = f1.lastModified();
        String time = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss").format(ftime);
        System.out.println("最后修改时间"+time);//2023年01月01日 15:48:39
        //6.判断是否是文件
        System.out.println(f1.isFile());//true
        //7.判断是否是文件夹
        System.out.println(f1.isDirectory());//false
        //8.路径表示的file是否存在
        System.out.println(f1.exists());//true
    }
}

B.创建和删除文件对象

在这里插入图片描述

import java.io.File;
import java.io.IOException;

public class filetest {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/com/test/file/img1.jpg");
        //1。创建文件，成功返回ture失败false
        System.out.println(f1.createNewFile());//false,已经存在
        File f2 = new File("src/com/test/file/data.txt");
        System.out.println(f2.createNewFile());//true

        //2.mkdir创建一级目录，mkdirs创建多级目录
        File f3 = new File("src/com/test/file/1");//一级目录
        System.out.println(f3.mkdir());//true
        File f4 = new File("src/com/test/file/10/20/30/40");//多级目录
        System.out.println(f4.mkdir());//false
        System.out.println(f4.mkdirs());//true

        //3.删除文件和空目录
        System.out.println(f3.delete());//true
        System.out.println(f4.delete());//ture，只删除空文件40
    }
}

C. 文件的遍历

在这里插入图片描述

import java.io.File;

public class filetest {
    public static void main(String[] args) {
        //定位文件
        File f1 = new File("src/com/test/file");
        //1.list获取所以文件名
        String[] names = f1.list();
        for (String name : names) {
            System.out.print(name+" ;");//10 ;data.txt ;filetest.java ;img1.jpg ;
        }
        //2.listFiles 获取所以文件对象
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file.isFile());//判断获取的是文件还是目录
        }
    }
}

在这里插入图片描述

D.非规律化递归—文件搜索

import java.io.File;

public class file1 {
    public static void main(String[] args) {
        File f1 = new File("D:\\");
        String fileName = "QQMusic";
        filesearch(f1,fileName);


    }

    private static void filesearch(File f, String fileName) {
    //判断是否是目录
        if (f != null && f.isDirectory()){
        //提取目录内所有的对象
            File[] files = f.listFiles();
            //判断是否目录，是否有内容
            if(files != null && files.length >= 0){
            //遍历目录
                for (File file : files) {
                //判断是否是文件
                    if (file.isFile()){
                    //如果是文件比较文件名。并输出文件位置
                        if (file.getName().contains(fileName)){
                            System.out.println(file.getAbsoluteFile());
                        }
                    }else {
                   //如果是目录，递归继续搜索
                        filesearch(file,fileName);
                    }
                }
            }

        }
    }


}

E.字符集—编码和解码操作

在这里插入图片描述

  • String编码
    在这里插入图片描述

  • String解码
    在这里插入图片描述

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //1.编码：文字转换成字节
        String say1 = "你说hello";
        String say2 = "我说hi";
        byte[] b1 = say1.getBytes();//默认UTF-8,中文3个字节
        byte[] b2 = say2.getBytes("GBK");//GBK中文两个字节
        System.out.println("b1的长度："+b1.length);//b1的长度：11
        System.out.println(Arrays.toString(b1));//[-28, -67, -96, -24, -81, -76, 104, 101, 108, 108, 111]
        System.out.println("b2的长度："+b2.length);//b2的长度：6
        System.out.println(Arrays.toString(b2));//[-50, -46, -53, -75, 104, 105]

        //2.解码：把字节转换成对应的形式（编码前后字符集一致）
        String s1 = new String(b1);//默认UTF-8
        System.out.println("s1的内容为："+s1);//s1的内容为：你说hello
        String s2 = new String(b2);
        String s3 = new String(b2,"GBK");
        System.out.println(s2);//��˵hi,字符集使用错误
        System.out.println(s3);//我说hi

    }
}

F.io流—输入流和输出流

  • io流的分类
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

a.FileInputStream字节输入流

在这里插入图片描述

import java.io.*;
import java.util.Arrays;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建文件字节输入流管道并与源文件连通
        InputStream i1 = new FileInputStream("src/file.txt");//文件内容：ab3
        
        //2.读一个字节返回read()
        //缺点：1.一个返回一个字节，中文3个字节会出错。2：性能较差
            //可使用循环
            // while(i1.read()!= -1){}
        System.out.println(i1.read());//97，返回int型ASCII编码
        System.out.println((char)i1.read());//b
        System.out.println((char)i1.read());//3
        System.out.println(i1.read());//-1,无内容
        

        //3.定义一个字符数组，用于读取字符数组read(bytes)
        InputStream i2 = new FileInputStream("src/data1");//内容为：5月5号123
        byte[] bytes = new byte[4];
            //可使用循环
            // while(i2.read(bytes) != -1){}
        int len = i2.read(bytes);//返回读取字节数
        System.out.println("读取字节数："+len);//4
        System.out.println(Arrays.toString(bytes));//[53, -26, -100, -120]
        String one =  new String(bytes);//解码
        System.out.println(one);//5月
            //第二次
        int len2 = i2.read(bytes);
        String two = new String(bytes);
        System.out.println(two);//5号
            //第三次
        int len3 = i2.read(bytes);
        System.out.println(len3);//3
        String three = new String(bytes,0,len3);
            //new String(bytes);//内容不足，最后一位出现乱码123�
        System.out.println(three);//123
            //第四次
        int len4 = i2.read();
        System.out.println(len4);//-1
        String four = new String(bytes);
        System.out.println(four);//123�

    }
}
  • 中文避免乱码

在这里插入图片描述

定义一个文件一样大的数组
readAllBytes();

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class test {
    public static void main(String[] args) throws IOException {
        InputStream f1 = new FileInputStream("src/data1");
        byte[] bytes = f1.readAllBytes();
        System.out.println(new String(bytes));//5月5号123
        
        System.out.println(bytes.length);//11，中文占3个字节

    }
}

b.FileOutputStream字节输出流

在这里插入图片描述

 package com.test.Fileoutputs;


import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建文件字节输出流与目标文件连通
        OutputStream o1 = new FileOutputStream("src/data1",true);//连通后会清空原数据,添加true参数变为追加数据

        //2.写数据
        o1.write(97);
        o1.write('a');
        o1.write('我');//aa，中文三个字节会出现乱码

        //3.写一个数组
        byte[] bytes = "写入中文" .getBytes();
        o1.write(bytes);//aa写入中文
        o1.write("\r\n".getBytes());//换行，\r\n兼容性更强

        //4.写入指定数量
        byte[] b1 = {'a','b','c','d'};
        o1.write(b1,0,3);//aa写入中文
        				// abc

        o1.close();
    }
}

在这里插入图片描述
在这里插入图片描述

1） 流的刷新与关闭

在这里插入图片描述

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建文件字节输出流与目标文件连通
        OutputStream o1 = new FileOutputStream("src/data1");

        //2.写数据
        o1.write(97);
        o1.write(98);
        o1.write('我');
        o1.write('爱');
        o1.write('你');
        //2.必须刷新数据。防止丢失
        o1.flush();
        //3。释放数据（包含刷新），一旦关闭不能再写入
        o1.close();
2）文件拷贝
import java.io.*;
public class test {
    public static void main(String[] args) throws IOException {
        //创建一个文本输入流与文件接通
        InputStream f1 = new FileInputStream("src/com/test/filecopy/f1.txt");//f1文件内容：你好

        //创建一个文本输出流与文件接通
        OutputStream f2 = new FileOutputStream("src/com/test/filecopy/f2.txt");//空文本文件

        //文件拷贝
        byte[] bytes = new byte[6];
        int len;
        while((len = f1.read(bytes)) != -1){
            f2.write(bytes,0,len);//复制f1内容

        }
        f1.close();
        f2.close();

    }

}

c.资源释放

在这里插入图片描述

无需手动关闭资源

  • jdk7
    在这里插入图片描述

  • jdk9

在这里插入图片描述

d.FileReader字符输入流

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  • FileReader
    在这里插入图片描述
  • 读取单个字符
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class test {
    public static void main(String[] args) throws IOException {
        //1.连通
        Reader f1= new FileReader("src/com/test/FileReader9d/file1");//内容为：你正在使用java

        //2.读取单个字符（循环），返回int型没有可读返回 -1
        int code;
        while ((code =f1.read() )!= -1){
            System.out.print((char) code);//你正在使用java
        }

    }
}
  • 读取字符串数组
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class test {
    public static void main(String[] args) throws IOException {
        //1.连通
        Reader f1= new FileReader("src/com/test/FileReader9d/file1");//内容为：你正在使用java

        //2.读取字符数组
        char[] arr= new char[1024];
        int len;
        while((len = f1.read(arr)) != -1){
            System.out.println(arr);//数组大小为1024，超出部分显示乱码
            //截取长度
            String s = new String(arr, 0, len);
            System.out.println(s);//你正在使用java
        }

    }
}

e.Filewriter字符输出流

  • 构造器
    在这里插入图片描述
  • 方法
    在这里插入图片描述
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class test {
    public static void main(String[] args) throws IOException {
        //1.连通
        Writer f1 = new FileWriter("src/com/test/FileReader9d/file2");

        //2.写一个字符
        f1.write(97);
        f1.write('b');
        f1.write('王');//不会出错
        f1.write(':');

        //3.写一串字符/数组
        f1.write("吃饭了吗");
        char[] chars = "李:没吃呢".toCharArray();
        f1.write(chars);

            //截取部分字符串
        f1.write("\r\n");//换行
        f1.write("王:明天有空吗出去玩？",0,7);//王:明天有空吗

            //截取数组
        char[] chars1 = "李:我明天没空，我要去北京".toCharArray();
        f1.write(chars1,0,7);//李:我明天没空

        //4.刷新数据
        f1.flush();//刷新可以继续使用流
        //5.关闭
        f1.close();//关闭不可以继续使用流

        //最后文本内容为：
        //ab王:吃饭了吗李:没吃呢
        //王:明天有空吗李:我明天没空
    }
}

G.io流—缓冲流

缓冲流可以提高原始字符流，字节流的读写性能

在这里插入图片描述

a.字节缓冲输入流/输出流

在这里插入图片描述

方法与基本流没有太大变化
在这里插入图片描述

  • 字节缓冲输入流

import java.io.*;

public class test {
    public static void main(String[] args) throws IOException {
        //1.连通
        InputStream f1 = new FileInputStream("src/file2");//内容：你正在学习java，加油
        //2.创建缓冲输入流
        InputStream bf1 = new BufferedInputStream(f1);

        //3.读取
        byte[] chars = new byte[100];
        int len;
        while((len=bf1.read(chars)) != -1){
            String s = new String(chars,0,len);
            System.out.println(s);//你正在学习java，加油
        }
    }
}
  • 字节缓冲输出流
import java.io.*;

public class test1 {
    public static void main(String[] args) throws IOException {
        //1.连通
        OutputStream f2 = new FileOutputStream("src/file2");
        //2.创建缓冲输出流
        OutputStream bf2 = new BufferedOutputStream(f2);

        //3.写入
        byte[] bytes = "你正在学习java，请继续努力".getBytes();
        bf2.write(bytes);

        //4.刷新和关闭
        bf2.flush();
        bf2.close();

    }
}

b.字符缓冲输入流/输出流

在这里插入图片描述

  • 字符缓冲输入流
    在这里插入图片描述
import java.io.*;

public class test2 {
    public static void main(String[] args) {
        try(
                //1.连通
                Reader r1 = new FileReader("src/file2");
                //2.绑定缓冲字符输入流
                BufferedReader br1 = new BufferedReader(r1);) {
            String line;
            //3.readLine()读取一行   
            while((line = br1.readLine())!= null ){
                System.out.println(line);//你正在学习java
                                        // 请继续努力
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}
  • 字符缓冲输出流
    在这里插入图片描述
import java.io.*;

public class test3 {
    public static void main(String[] args) throws IOException {
        //1.连通
        Writer f1 = new FileWriter("src/file2");
        BufferedWriter bf1 = new BufferedWriter(f1);

        //2.写一个字符
        bf1.write(97);
        bf1.write('b');
        bf1.write('王');//不会出错
        bf1.write(':');
        //3.写一串字符/数组
        bf1.write("吃饭了吗");
            //newLine()换行 
        bf1.newLine();
        char[] chars = "李:没吃呢".toCharArray();
        bf1.write(chars);

        //截取部分字符串
        bf1.write("\r\n");//换行
        bf1.write("王:明天有空吗出去玩？",0,7);//王:明天有空吗
        bf1.newLine();

        //截取数组
        char[] chars1 = "李:我明天没空，我要去北京".toCharArray();
        bf1.write(chars1,0,7);//李:我明天没空

        //4.刷新数据
        bf1.flush();//刷新可以继续使用流
        //5.关闭
        bf1.close();//关闭不可以继续使用流

        //最后文本内容为：
        //ab王:吃饭了吗
        //李:没吃呢
        //王:明天有空吗
        //李:我明天没空
    }
}

H.io流—转换流

在这里插入图片描述

在这里插入图片描述

a.字符输入转换流

inputStreamReader,把原始字节流按照指定编码转换成字符输入流
在这里插入图片描述

在这里插入图片描述

public class test4 {
    public static void main(String[] args) throws IOException {
        //1.连通
        FileInputStream f1= new FileInputStream("src/com/test/BStrea9/GBK.txt");//该文本为GBk的方式
        int s;
//        while ((s = f1.read()) != -1){
//            System.out.print((char) s);//乱码
//        }

        //2.转换流
        InputStreamReader f1r = new InputStreamReader(f1,"GBk");//默认使用UTF-8
            //读取
        while ((s = f1r.read()) != -1){
            System.out.print((char) s);//这是一个gbk文本
        }
    }
}

b.字符输出转换流

OutputStreamWriyer,把原始字节输出流按照指定编码转换成字符输出流
在这里插入图片描述

在这里插入图片描述

import java.io.*;

public class test5 {
    public static void main(String[] args) throws IOException {
        //1.连通
        FileOutputStream f1 = new FileOutputStream("src/com/test/BStrea9/GBK.txt");
        //2.转换流,指定编码
        OutputStreamWriter gbk = new OutputStreamWriter(f1, "Gbk");//默认UTF-8

        //3.把低级流转换成高级流
        BufferedWriter bf1 = new BufferedWriter(gbk);
        //4.写入
        bf1.write("正在使用GBK格式");
        bf1.close();
    }
}

I.对象序列化

在这里插入图片描述
在这里插入图片描述

a.对象字节输出流

在这里插入图片描述

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class test {
    public static void main(String[] args) throws IOException {
        //1.创建对象
        S1 s = new S1("wang",18);

        //2.连通文件
        FileOutputStream f = new FileOutputStream("src/file");

        //3.使用对象序列化流
        ObjectOutputStream o = new ObjectOutputStream(f);

        //3.调用对象序列化方法，写入对象
        o.writeObject(s);//S1{name='wang', age=0}

        o.close();

    }
}

class S1

import java.io.Serializable;

//必须实现Serializable接口
public class S1 implements Serializable {
    private String name;
    //transient修饰的不参与序列化
    private transient int age;

    public S1(String name, int age) {
        this.name = name;
        this.age = age;
    }

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


    @Override
    public String toString() {
        return "S1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 对象要序列化必须实现Serializable接口
  • transient修饰的不参与序列化 private transient int age;
    在这里插入图片描述

b. 对象字节输出流

import java.io.*;

public class test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建对象
        S1 s = new S1("wang",18);

        //2.连通文件
        FileInputStream f1 = new FileInputStream("src/file2");

        //3.使用对象序列化流
        ObjectInputStream o1 = new ObjectInputStream(f1);

        //3.调用对象序列化方法，读取对象
        S1 os = (S1) o1.readObject();
        System.out.println(os);//S1{name='wang', age=0}


    }
}

import java.io.Serializable;

//必须实现Serializable接口
public class S1 implements Serializable {
    private String name;
    //transient修饰的不参与序列化
    private transient int age;

    public S1(String name, int age) {
        this.name = name;
        this.age = age;
    }

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


    @Override
    public String toString() {
        return "S1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  • 拓展

在这里插入图片描述

J.打印流

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

a.printStream

printStream高级流可以不需要先连接低级流

在这里插入图片描述
在这里插入图片描述

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class test {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream p1 = new PrintStream("src/file.txt");
        //PrintStream p1 = new PrintStream(new FileOutputStream("src/file.txt",true));//添加true参数
        p1.println(97);
        p1.println("abc");
        p1.println('d');
        p1.println(true);

        //97
        //abc
        //d
        //true

    }
}

b.printWriter

在这里插入图片描述

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class test {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter p1 = new PrintWriter("src/file.txt");
        p1.println(1000);
        p1.println("qwe");
        p1.println('r');
        p1.println(false);

        p1.close();
        //1000
        //qwe
        //r
        //false
    }
}

c.输出语句的重定向

在这里插入图片描述
在这里插入图片描述

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class test {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("这个数据打印会打印到控制台");
        
        1.输出语句重定向
        PrintStream p1 = new PrintStream("src/file.txt");
        System.setOut(p1);
        System.out.println("这个数据会打印到文件");
        
    }
}

在这里插入图片描述

d.拓展properties

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 存信息
    在这里插入图片描述
  • 读取内容

在这里插入图片描述

K.框架

  • commons-io
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

10.多线程

A.线程的创建

在这里插入图片描述

方法一：继承Thread

在这里插入图片描述

public class test {
    public static void main(String[] args) {
    //1.创建一个子线程
        MyThread myThread = new MyThread();
        myThread.start();
		//主线程
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程运行中"+ i);
        }
    }

}

class MyThread extends Thread{
//重写run()方法
    @Override
    public void run() {			//运行内容
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程运行中："+ i);
        }
    }
}

在这里插入图片描述

缺点：无法再继承其他类

方法二：实现Runnable接口

在这里插入图片描述
在这里插入图片描述

public class test2 {
    public static void main(String[] args) {
    //1。创建子线程
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable);
        t.start();
		//主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(i + "+++主线程+++");
        }

    }
}

//实现Runnable接口
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i+"===子线程===");
        }
    }
}

在这里插入图片描述

  • 实现Runnable接口（内部类）在这里插入图片描述
public class test2 {
    public static void main(String[] args) {
        //1.使用内部类
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i+"---子线程1---");
                }
            }
        };

        //创建子线程
        Thread t = new Thread(myRunnable);
        t.start();
        
        //2.简化
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i+"===子线程2==="+i);
                }
            }
        }).start();
        //3.lambda简化
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i+"###子线程3###"+i);
            }
        }).start();


        for (int i = 0; i < 10; i++) {
            System.out.println(i + "主线程");
        }

    }
}

方法三：实现Callable，FutureTask接口

在这里插入图片描述

  • 使用方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class test3 {
    public static void main(String[] args) {
        //1.创建一个MYcallable任务对象
        Mycallable mc = new Mycallable();
        //2.创建一个FutureTask对象，将MYcallable任务对象交给FutureTask
        FutureTask<String> sTask = new FutureTask<String>(mc);
        //3.创建线程
        Thread t = new Thread(sTask);
        t.start();

        //4.get()方法获取返回值
        //调用的是FuturnTask对象
        try {
            System.out.println(sTask.get());//你好45
        } catch (InterruptedException e) {

        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}

class Mycallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        int n = 0;
        for (int i = 0; i < 10; i++) {
            n += i;
        }
        return "你好"+n;
    }
}

在这里插入图片描述

B.Thread的常用方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class test {
    public static void main(String[] args) {
        //1.创建子线程
        Thread myThread = new MyThread();
        myThread.start();
            //获取线程名
        System.out.println(myThread.getName());//Thread-0

        //创建子线程2
        Thread myThread2 = new MyThread2();
        myThread2.start();
        	//设置线程名
        myThread2.setName("=2=");
        System.out.println(myThread2.getName());//=2=

        //2.获取当前线程名
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());


        for (int i = 0; i < 2; i++) {
            System.out.println("主线程运行中"+ i);
        }
    }

}

//继承Thread对象
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"子线程运行中："+ i);
            //休眠指定时间
                    Thread.sleep(3000);

            }
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"子线程运行中："+ i);
        }
    }
}

在这里插入图片描述

  • 通过构造器直接命名
    在这里插入图片描述
public class test {
    public static void main(String[] args) {
        //1.创建子线程
        	//通过构造器直接命名
        Thread myThread = new MyThread("002");
        myThread.start();
            //获取线程名
        System.out.println(myThread.getName());//Thread-0

        for (int i = 0; i < 2; i++) {
            System.out.println("主线程运行中"+ i);
        }
    }

}
继承Thread对象
class MyThread extends Thread{
    public MyThread() {
    }
    //为当前对象设置名字
    public MyThread(String name) {
    //送给父类构造器初始化名称
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"子线程运行中："+ i);
        }
    }
}

在这里插入图片描述

C.线程同步的三种方法

a.线程同步代码块

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  • 锁对象的选择
    在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

b.同步方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

c.Lock锁

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

D.线程通信

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

F.线程池

在这里插入图片描述
在这里插入图片描述

a.参数说明

  • 构造器参数说明
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

b.线程池处理Runnable任务

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
// MyRunnable

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName()+"输出====》"+i);
        }
    }
}

//主程序

import java.util.concurrent.*;

public class test {
    public static void main(String[] args) {
        /*
        public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
        * */
        ExecutorService pool = new ThreadPoolExecutor( 3,5,
                6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable myRunnable = new MyRunnable();
        //1.execute
            //由核心线程执行
        pool.execute(myRunnable);
        pool.execute(myRunnable);
        pool.execute(myRunnable);
            //不会创建 临时线程，存放在队列中等待执行
        pool.execute(myRunnable);
        pool.execute(myRunnable);
        pool.execute(myRunnable);
        pool.execute(myRunnable);
        pool.execute(myRunnable);
            //创建临时线程，由于3个核心线程与队列都满了
        pool.execute(myRunnable);
        pool.execute(myRunnable);
            //由于最大线程为5，所以会报错
        //t.execute(myRunnable);

        //2.关闭线程池（一般不使用）
        /*
        pool.shutdown();//等待所以任务完成后关闭
        pool.shutdownNow()//立即关闭，丢失任务
        */
    }
}

c.线程池处理Callable任务

在这里插入图片描述
//MyCallable

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()+"结果为===》"+sum;
    }
}

//主程序

import java.util.concurrent.*;

public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(3,5,
                6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        //1.submit
        Future<String> s1= pool.submit(new MyCallable());
        Future<String> s2= pool.submit(new MyCallable());
        Future<String> s3= pool.submit(new MyCallable());
		//获取返回值
        System.out.println(s1.get());
        System.out.println(s2.get());
        System.out.println(s3.get());
    }
}

G.Executors工具类实现线程池

在这里插入图片描述

//MyRunnable

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName()+"输出====》"+i);
        }
    }
}

//主程序

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test1 {
    public static void main(String[] args) {
        //newFixedThreadPool，设置固定数量3个
        ExecutorService e = Executors.newFixedThreadPool(3);
        //2.执行任务
        e.execute(new MyRunnable());
        e.execute(new MyRunnable());
        e.execute(new MyRunnable());

        e.execute(new MyRunnable());//在队列中等待
    }
}

在这里插入图片描述
在这里插入图片描述

H.定时器

在这里插入图片描述
在这里插入图片描述

a.Timer

在这里插入图片描述

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class test {
    public static void main(String[] args) {
        Timer timer = new Timer();

        //1.schedule
        //定时3秒，只执行一次
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"你准备好了吗"+new Date());
            }
        },3000);

        //首次执行3秒，后续等待2秒
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了"+new Date());
            }
        },3000,2000);


    }
}

在这里插入图片描述

在这里插入图片描述

b.ScheduledExecutorService

在这里插入图片描述

import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class test2 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService s= Executors.newScheduledThreadPool(3);
        // 1.scheduleAtFixedRate
        //（执行内容，第一次执行等待3秒，后续2秒，单位秒）
        s.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了"+new Date());
            }
        },3,2, TimeUnit.SECONDS);
    }
}

I.线程的六种状态

在这里插入图片描述

11.网络编程

在这里插入图片描述

A.网络通信的三要素

在这里插入图片描述
在这里插入图片描述

a.ip地址

在这里插入图片描述

import java.io.IOException;
import java.net.InetAddress;
public class test {
    public static void main(String[] args) throws IOException {
        //1.getLocalHost()获取本地ip
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1.getHostName());//LAPTOP-Q0PSIA8D
        System.out.println(ip1.getHostAddress());//192.168.2.6

        //2.getByName通过域名获取ip
        InetAddress ip2 = InetAddress.getByName("www.baidu.com");
        System.out.println(ip2.getHostName());//www.baidu.com
        System.out.println(ip2.getHostAddress());//180.101.50.188

        //3.通过ip地址获取公网ip
        InetAddress ip3 = InetAddress.getByName("180.101.50.188");
        System.out.println(ip3.getHostName());//www.baidu.com
        System.out.println(ip3.getHostAddress());//180.101.50.188

        //4.3秒后判断是否ping通
        System.out.println(ip3.isReachable(3000));//true
    }
}

b.端口号与通信协议

端口
在这里插入图片描述

通信协议在这里插入图片描述

B.UDP

在这里插入图片描述

a.UDP单播—收发数据

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
//发送端

public class send {
    public static void main(String[] args) throws IOException {
        System.out.println("===客户端启动===");
        //1.创建发送的对象
        DatagramSocket socket = new DatagramSocket();
        
        //2.创建一个数据包发送的数据容器
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        byte[] buffer = "这是一份数据".getBytes();
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length,InetAddress.getLocalHost(),8888);

        //3.发送数据
        socket.send(packet);
        socket.close();
    }
}

//接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class receive {
    public static void main(String[] args) throws IOException {

        System.out.println("===服务端启动===");
        //创建接收数据的对象
        DatagramSocket socket = new DatagramSocket(8888);

        //2.创建一个数据包接收的数据
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        //3.等待接收数据
        socket.receive(packet);

        //4.getLength()获取到的数据长度
        int len = packet.getLength();
        String s = new String(buffer,0,len);
        System.out.println("收到数据:"+s);
        socket.close();

        //5.
        String s1 = packet.getAddress().toString();
        System.out.println("对方的ip："+s1);

        int port = packet.getPort();
        System.out.println("对方的端口:"+port);
    }
}

在这里插入图片描述

+  实现多发和多收![在这里插入图片描述](https://img-blog.csdnimg.cn/a851433121544372828f3c3df864cdbc.png)

在这里插入图片描述
在这里插入图片描述
//发送端

import java.io.IOException;
import java.net.*;
import java.util.Scanner;


public class send {
    public static void main(String[] args) throws IOException {
        System.out.println("===客户端启动===");
        //1.创建发送的对象
        DatagramSocket socket = new DatagramSocket();
        
        //2.创建一个数据包发送的数据容器
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        Scanner send = new Scanner(System.in);

        while (true) {
            System.out.println("请您输入要发送的内容：");
            String s = send.nextLine();

            if ("exit".equals(s)){
                System.out.println("===客户端已退出===");
                socket.close();
                break;
            }
            byte[] buffer = s.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer,buffer.length,InetAddress.getLocalHost(),8888);

            //3.发送数据
            socket.send(packet);
        }
        socket.close();
    }
}

在这里插入图片描述

//接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class receive {
    public static void main(String[] args) throws IOException {

        System.out.println("===服务端启动===");
        //创建接收数据的对象
        DatagramSocket socket = new DatagramSocket(8888);

        //2.创建一个数据包接收的数据
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        while (true) {
            //3.等待接收数据
            socket.receive(packet);

            //4.getLength()获取到的数据长度
            int len = packet.getLength();
            String s = new String(buffer,0,len);
            System.out.println("收到来自："+packet.getAddress()+"的数据:" +s);
        }

    }
}

在这里插入图片描述
在这里插入图片描述

b.UDP的广播与组播

  • 广播
    在这里插入图片描述
    在这里插入图片描述
  • 组播
    在这里插入图片描述

//接收端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;

public class receive {
    public static void main(String[] args) throws IOException {

        System.out.println("===服务端启动===");
        //1.创建接收数据的对象
//        DatagramSocket socket = new DatagramSocket(8888);
        MulticastSocket socket = new MulticastSocket(8888);

        //将当前接收端加入到组播组中去
        socket.joinGroup(InetAddress.getByName("224.0.1.1"));

        //2.创建一个数据包接收的数据
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        while (true) {
            //3.等待接收数据
            socket.receive(packet);

            //4.getLength()获取到的数据长度
            int len = packet.getLength();
            String s = new String(buffer,0,len);
            System.out.println("收到来自："+packet.getAddress()+"的数据:" +s);
        }

    }
}

在这里插入图片描述

//发送端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;


public class send {
    public static void main(String[] args) throws IOException {
        System.out.println("===客户端启动===");
        //1.创建发送的对象
        DatagramSocket socket = new DatagramSocket();
        
        //2.创建一个数据包发送的数据容器
/*         public DatagramPacket(byte[] buf, int length,
        InetAddress address, int port)*/
        Scanner send = new Scanner(System.in);

        while (true) {
            System.out.println("请您输入要发送的内容：");
            String s = send.nextLine();

            if ("exit".equals(s)){
                System.out.println("===客户端已退出===");
                socket.close();
                break;
            }
            byte[] buffer = s.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer,buffer.
                    length,InetAddress.getByName("224.0.1.1"),8888);

            //3.发送数据
            socket.send(packet);
        }
        socket.close();
    }
}

在这里插入图片描述
在这里插入图片描述

C.TCP

在这里插入图片描述

a.收发数据

在这里插入图片描述
在这里插入图片描述

发送端

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

public class send {
    public static void main(String[] args) {
        try {
            //1.创建Scocket通信管道
            // Socket（本机地址，端口）
            Socket socket = new Socket("127.0.0.1",8888);
            //2.连接字节输出输出流
            OutputStream out = socket.getOutputStream();
            //3.将低价流包装成打印流
            PrintStream ps = new PrintStream(out);

            ps.println("你好我来自火星");
            ps.flush();

            socket.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

在这里插入图片描述

//接收端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class receive {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket server = new ServerSocket(8888);

            //2.连通管道,等待客户端连接请求
            Socket accept = server.accept();

            //3.从Socket中通信管道中得到一个字节输入流
            InputStream i = accept.getInputStream();

            //4.使用转换流，将字节输入流转换为字符输入流并包装为高级流
            BufferedReader br1 = new BufferedReader(new InputStreamReader(i));

            //5.
            String line;
            if ((line=br1.readLine() )!= null){
                System.out.println("来自："+accept.getRemoteSocketAddress()+"发出的内容："+line);
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

拓展 —多发多收

在这里插入图片描述

//发送端

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class send {
    public static void main(String[] args) {
        try {
            System.out.println("===客户端已启动===");
            //1.创建Scocket通信管道
            // Socket（本机地址，端口）
            Socket socket = new Socket("127.0.0.1",8888);
            //2.连接字节输出输出流
            OutputStream out = socket.getOutputStream();
            //3.将低价流包装成打印流
            PrintStream ps = new PrintStream(out);

            //4.
            Scanner scanner = new Scanner(System.in);
            while (true) {

                String s = scanner.nextLine();
                if("exit".equals(s)){
                    System.out.println("===客户端已关闭===");
                    socket.close();
                    break;
                }
                ps.println(s);
                ps.flush();
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

在这里插入图片描述

//接收端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class receive {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端已启动===");
            //1.注册端口
            ServerSocket server = new ServerSocket(8888);

            //2.连通管道,等待客户端连接请求
            Socket accept = server.accept();

            //3.从Socket中通信管道中得到一个字节输入流
            InputStream i = accept.getInputStream();

            //4.使用转换流，将字节输入流转换为字符输入流并包装为高级流
            BufferedReader br1 = new BufferedReader(new InputStreamReader(i));

            //5.

                String line;
                while((line=br1.readLine() )!= null){
                    System.out.println("来自："+accept.getRemoteSocketAddress()+"发出的内容："+line);

            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

在这里插入图片描述

拓展 —多客户端

在这里插入图片描述

//发送端

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class send {
    public static void main(String[] args) {
        try {
            System.out.println("===客户端已启动===");
            //1.创建Scocket通信管道
            // Socket（本机地址，端口）
            Socket socket = new Socket("127.0.0.1",8888);
            //2.连接字节输出输出流
            OutputStream out = socket.getOutputStream();
            //3.将低价流包装成打印流
            PrintStream ps = new PrintStream(out);

            //4.
            Scanner scanner = new Scanner(System.in);
            while (true) {

                String s = scanner.nextLine();
                if("exit".equals(s)){
                    System.out.println("===客户端已关闭===");
                    socket.close();
                    break;
                }
                ps.println(s);
                ps.flush();
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

在这里插入图片描述
在这里插入图片描述

//接收端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class receive {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端已启动===");
            ServerSocket server = new ServerSocket(8888);

            while(true){
                Socket accept = server.accept();
                new severThread(accept).start();
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

//子线程

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class severThread extends Thread{
    private Socket socket;
    public severThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {

            InputStream i = socket.getInputStream();

            //4.使用转换流，将字节输入流转换为字符输入流并包装为高级流
            BufferedReader br1 = new BufferedReader(new InputStreamReader(i));
            String line;
            while((line=br1.readLine() )!= null){
                System.out.println("来自："+socket.getRemoteSocketAddress()+"发出的内容："+line);

            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

在这里插入图片描述

拓展 —线程池优化多客户端

在这里插入图片描述

//发送端

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class send {
    public static void main(String[] args) {
        try {
            System.out.println("===客户端已启动===");
            //1.创建Scocket通信管道
            // Socket（本机地址，端口）
            Socket socket = new Socket("127.0.0.1",8888);
            //2.连接字节输出输出流
            OutputStream out = socket.getOutputStream();
            //3.将低价流包装成打印流
            PrintStream ps = new PrintStream(out);

            //4.
            Scanner scanner = new Scanner(System.in);
            while (true) {

                String s = scanner.nextLine();
                if("exit".equals(s)){
                    System.out.println("===客户端已关闭===");
                    socket.close();
                    break;
                }
                ps.println(s);
                ps.flush();
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

//接收端

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

public class receive {
    private static ExecutorService pool = new ThreadPoolExecutor( 3,5,
            6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
    public static void main(String[] args) {

        try {
            System.out.println("===服务端已启动===");
            ServerSocket server = new ServerSocket(8888);

            while(true){
                Socket accept = server.accept();
                severThread target = new severThread(accept);
                pool.execute(target);
            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

//子线程

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.concurrent.*;

public class severThread implements Runnable{
    private Socket socket;

    public severThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {

            InputStream i = socket.getInputStream();

            //4.使用转换流，将字节输入流转换为字符输入流并包装为高级流
            BufferedReader br1 = new BufferedReader(new InputStreamReader(i));
            String line;
            while((line=br1.readLine() )!= null){
                System.out.println("来自："+socket.getRemoteSocketAddress()+"发出的内容："+line);

            }


        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

拓展 --B/S

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

12.单元测试

a.junit基础

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

b.junit常用注解

在这里插入图片描述

在这里插入图片描述

13.反射

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

(1).获取Class对象

在这里插入图片描述
在这里插入图片描述

  • 三种方式
    在这里插入图片描述

A.获取构造器对象

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用构造器

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

B.获取成员变量

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

成员变量赋值与取值

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

C.获取方法对象

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

执行方法

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

(2).反射的作用

A.绕过编译阶段为集合添加参数

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

14.注解

在这里插入图片描述

A.自定义注解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

B.元注解

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

C.注解的解析

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

15.代理

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

16.XMl

在这里插入图片描述

A.文件文件创建

在这里插入图片描述

  • 文档声明
    在这里插入图片描述
  • 规则
    在这里插入图片描述
    在这里插入图片描述

B.约束

在这里插入图片描述

a.DTD

在这里插入图片描述
在这里插入图片描述

b.schema

在这里插入图片描述
在这里插入图片描述

C.解析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

a.dom4j

在这里插入图片描述
在这里插入图片描述

D.检索技术

在这里插入图片描述
在这里插入图片描述

我的建议是不如回家种田
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习路线总结（思维导图篇）
学Java，找哪吒
10-21 18万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java学习路线(鱼皮)
07-22
Java学习路线（鱼皮） Java学习路线（鱼皮）是一条龙版本的学习路线，从入门到入土，旨在帮助学习者快速掌握Java开发的所有知识点。本路线的特点是新、完整、实用、开源、回馈社区、持续更新。 学习路线的主要...
xxx is assigned a value but never used 报错
莉兹Liz的博客
03-10 1743
xxx is assigned a value but never used报错 找到路径 package.json文件 -> devDependencies -> rules 添加以下代码 "rules": { "generator-star-spacing": "off", "no-debugger": "off", "no-tabs": "off", "no-unused-vars": "off", "no-console":
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
史上最强 Java 学习路线图！
热门推荐
沉默王二
04-24 27万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
推荐10个堪称神器的 Java 学习网站
沉默王二
10-28 14万+
Java学习网站，有了这些，成为大牛不在话下
Java学习路线（完整详细版）超详细
曾昭武
05-14 25万+
一门永不过时的编程语言——Java 软件开发。 Java编程语言占比： 据官方数据统计，在全球编程语言工程师的数量上，Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程，因此其程序员的数量最多。而在以Java编程为核心的开发领域中，javaEE程序员的需求量10年来一直居于首位！ Java工程师就业： 1.通过各大招聘网站统计，全国海量公司都在招聘J...
从入门到精通，Java学习路线导航
。。。
11-12 15万+
引言 最近也有很多人来向我"请教"，他们大都是一些刚入门的新手，还不了解这个行业，也不知道从何学起，开始的时候非常迷茫，实在是每天回复很多人也很麻烦，所以在这里统一作个回复吧。 Java学习路线 当然，这里我只是说Java学习路线，因为自己就是学Java的，对Java理当很熟悉，对于其它方面，我也不是很了解。 基础阶段 首先是基础阶段，在基础阶段，我们必须掌握Java基础，Mysql数据库，Ora...
Java 学习路线
zr_1877的博客
01-06 3万+
对于入门java将近两年的时间，曾经迷惘过，一直想知道java的具体学习路线，看过了许许多多的java经验分享的帖子，评论，以及其他各种培训机构所谓的学习路线，发现没有一个符合我个人需求的学习路线，根据个人实际的经历，结合多种书籍（其中个人觉得“疯狂java讲义”这本书写的特别好，所以大部分是根据这本书整理的），特别整理出了下面的java学习路线，跟大家分享，觉得好的话，希望大家多多指点，下面进入
Java学习心得感悟
m0_74186782的博客
09-15 4999
Java作为一种跨平台、面向对象的编程语言，具有强大的扩展性和可移植性，一直以来都是IT行业中最受欢迎的编程语言之一。在我学习Java的过程中，我深刻地认识到了它的重要性和强大的威力，下面是我对Java学习的一些感悟和心得，希望能对同学们有所启发。
java学习路线24版
Ostkakah的博客
11-03 9133
作为大四老学长的秃狼，近日收到大量兄弟们的私信，希望我能出一期java学习路线的视频，很多小伙伴也是大一的新生，都想和我一样做最美逆行者。还有一些非科班准备转码的小伙伴，不想走培训班那条路线想要通过自学找Java工作。鼠鼠我呀就是宠粉，整！！！！！！！
JAVA学习全套PPT
04-24
【JAVA编程学习】是计算机科学领域的一个重要主题，尤其对于初学者来说，它是一个非常有价值的起点。Java是一种广泛使用的面向对象的编程语言，以其“一次编写，到处运行”的特性而闻名，这得益于Java虚拟机（JVM）...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 190
使用TCP协议支持与多个客户端同时通信。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 610
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 529
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 568
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Java学习资源与教程推荐
"这篇资源是关于Java学习的参考资料列表，包含多个知名作者的书籍和教程，如Bruce Eckel的《Thinking in Java》、Cay Horstmann的《Core Java 2 Volume 1 – Fundamentals》以及Kathy Sierra的《Head First Java》等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值