Java基础

优先级: 2 学习权重: 9 学习目标: 了解基础语法、学习序列化及反序列化等相关知识点 学习类型: 编程/语法学习 学习进度: 0.68 状态: 进行中 语言类别: Java

IDEA操作

新建项目》新建模块》src中新建软件包》新建类文件

demo 数组遍历

package com.test1;

public class hello{
    public static void main(String[] args) {
        System.out.println("test");
        int[] arr = new int[3];
        int[] arr2 = new int[]{1,2,3};
        int[] arr3 = {1,2,3};
        for(int i=0;i<arr3.length;i++){ //语句间用分号 ,变量需要声明类型 如 int a =0
            System.out.println(arr[i]);
        }

        arr[0] = 10;
        System.out.println(arr); //打印内存空间地址 [I@330bedb4
        System.out.println(arr[0]);
    }
}

demo 方法同java文件内调用

package com.test1;

public class hello{
    public static void main(String[] args) {
        System.out.println("test");
        int[] arr = new int[3];
        int[] arr2 = new int[]{1,2,3};
        int[] arr3 = {1,2,3};
        for(int i=0;i<arr3.length;i++){ //语句间用分号 ,变量需要声明类型 如 int a =0
            System.out.println(arr[i]);
        }

        arr[0] = 10;
        System.out.println(arr); //打印内存空间地址 [I@330bedb4
        System.out.println(arr[0]);
        isevennumber(11);
        System.out.println(isevennumber2(12));
    }
    public static void  isevennumber(int num){
//        int num =10;
        if (num%2 ==0){
            System.out.println("是偶数");
        }else {
            System.out.println("是奇数");
        }
    }

    public static boolean isevennumber2(int num){
        if (num%2 ==0){
            System.out.println("是偶数");
            return true;
        }else {
            System.out.println("是奇数");
            return false;
        }
    }
}

public static void 中void代表无返回值,直接return或省略return

demo 方法重载

  • 同一个类中
  • 方法名相同
  • 参数的类型或数量不同
package com.test1;

public class hello{
    public static void main(String[] args) {
        System.out.println(sum(1,2,3));
    }
    public static int sum(int b,int a ){
        return a+b;
    }
    public static float sum(float b,float a ){
        return a+b;
    }
    public static int sum(int b,int a,int c ){
        return a+b+c;
    }
}

demo 类和对象

package com.democlass;

public class democlass {
    String brand;
    int price;

    public void call() {
        System.out.println(this.brand +"is calling");
    }
    public void text() {
        System.out.println(brand +"is texting");

    }

}
package com.democlass;

public class demotest {
    public static void main(String[] args) {
        democlass P = new democlass();
        P.brand = "huawei";
        P.call();
        P.text();
    }
}

demo 成员变量和局部变量

/images/JavaBase/Untitled.png

demo private关键词

  • 权限修饰符
  • 修饰成员变量和方法
  • 保护成员不被其他类调用
  • 提供对应的get数据和set数据方法
package com.democlass;

public class democlass {
    String brand;
    private int price;

    public void setPrice(int p){
        if (p > 0) {
            price = p;
        }else {
            System.out.println("输入有误");
        }

    }

    public int getPrice() {
        return price;
    }

    public void call() {
        System.out.println(this.brand +"is calling");
    }
    public void text() {
        System.out.println(brand +"is texting");

    }

}
package com.democlass;

public class demotest {
    public static void main(String[] args) {
        democlass P = new democlass();
        P.brand = "huawei";
        P.call();
        P.text();
        P.setPrice(100);
        System.out.println(P.getPrice());
    }
}

在局部变量与成员变量同名十需要用this

![/images/JavaBase/Untitled 1.png](/images/JavaBase/Untitled 1.png)

demo 构造方法

package com.test;

public class Student {
    public String name;
    public int age;
    public Student(){
        System.out.println("无参构造方法");
    }
		public Student(String name){
				this.name= name;
        System.out.println("创建用户"+this.name);
    }
		public Student(String name, int age){
				this.name= name;
				this.age= age;
        System.out.println("创建用户"+this.name);
    }
    
}

无参构造方法在new Student类时会默认执行,类似于go调用时init函数。

不自定义构造方法时系统会默认给出构造方法

构造方法可实现重载。

demo 标准类制作 —(标准)

  • 成员变量使用private修饰
  • 设置成员方法
    • 提供设置成员变量对应的setXXX()/getXXX()
    • 提供显示对象信息的show()
  • 构造方法:提供一个无参构造方法并提供带多个参数的构造方法
  • 创建对象并为变量赋值的两种方式
    • 使用setXXX()赋值
    • 受用多个参数的构造方法直接赋值

demo API(application programming interface)应用程序编程接口

调用方法 可用option/alt + 回车键快速补全

package demo02;

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
//        int i =sc.nextInt();  //获取int值
//        String str = sc.nextLine(); //获取一行字符串
        String str = sc.nextLine();
        System.out.println(str);

    }
}

demo String类 及 构造方法

  • String不可改变,值在创建后不可改变
  • 字符串效果上相当于字符数组char[],但是底层原理是字节数组byte[]
package com.demostring;

public class string {
    public static void main(String[] args) {
        byte[] bys = {98, 99, 100};
        String s1 = new String(bys);
        System.out.println(s1);
        String s2 = "string";
    }
}

demo 字符串比较 equals()

  • 比较字符串是否相同 尽量使用equals

![/images/JavaBase/Untitled 2.png](/images/JavaBase/Untitled 2.png)

demo StringBuilder方法

StringBuilder是一个可变字符类

package com.demostring;

public class string {
    public static void main(String[] args) {
        StringBuilder sb =new StringBuilder();
        sb.append("hello ");
        sb.append("world ");
        sb.append(100);

        sb.append("hello ").append(100);

        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);
    }
}

demo StringBuilder String 相互转换

package com.demostring;

public class string {
    public static void main(String[] args) {
        StringBuilder sb =new StringBuilder();
        sb.append("hello ");
        sb.append("world ");
        
        String str = sb.toString();
        StringBuilder sbnew =new StringBuilder(str);
       
        System.out.println(sb);
        
    }
}

demo ArrayList()

类似于可变数组

package com.demoarray;

import java.util.ArrayList;

public class demoarray {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("hello");
        arr.add("world");

        arr.add(1,"test "); //集合会出现索引越界

        arr.remove("test ");
        arr.set(1,"world2"); //修改元素

        System.out.println(arr.get(2)); //获取元素
      
				System.out.println(arr.size()); //获取元素数量
        System.out.println(arr);
    }
}

demo ArrayList() 自定义类型

类似于二维数组

demo 继承

继承是具有相同属性的一类对象

子类

package com.demoinheritance;

public class Student extends Person { //子类必须声明父类继承关系
    public void Learn(){
        System.out.println("learn");
    }
}

父类

package com.demoinheritance;

public class Person {

    public void Say(){
        System.out.println("say");
    }
}

调用

package com.demoinheritance;

public class Demo {
    public static void main(String[] args) {
        Student s1 =new Student();
        s1.Say();
    }
}

demo super 关键字

this访问的是成员变量, super访问父类重的变量,都不加访问的是成员变量

方法重写

@Override 声明方法重写

父类中的私有内容不可被方法重写

继承注意事项

Java支持多层继承

Java不能单继承,不能同时继承多个类

demo final绝户修饰符

final修饰方法不可被重写

pubilc final void test(){}

final修饰的变量不可再被修改

final 修饰的类不可作为父类

![/images/JavaBase/Untitled 3.png](/images/JavaBase/Untitled 3.png)

demo static静态修饰符

使对象的变量被所有成员共享

静态的成员方法只能访问静态成员

多态

![/images/JavaBase/Untitled 4.png](/images/JavaBase/Untitled 4.png)

程序中多态提现

调用时变量看左边生命的变量,运行时如有方法重写,调用右侧对象方法

调用

package com.polymorphism;

public class demo {
    public static void main(String[] args) {
        Person p1 = new Student();
        System.out.println(p1.name);
//        System.out.println(p1.readclass); //新建的需要看左边,编译和运行,所以无法调用子类中的成员变量
        p1.say(); //成员方法看右边的对象方法
        //"C:\Program Files\Java\jdk1.8.0_291\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar=50935:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_291\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\rt.jar;E:\JavaWorkSpace\project1\out\production\test;E:\JavaWorkSpace\project1\lib\kotlin-stdlib.jar;E:\JavaWorkSpace\project1\lib\kotlin-reflect.jar;E:\JavaWorkSpace\project1\lib\kotlin-test.jar;E:\JavaWorkSpace\project1\lib\kotlin-stdlib-jdk7.jar;E:\JavaWorkSpace\project1\lib\kotlin-stdlib-jdk8.jar" com.polymorphism.demo
        //null
        //i am student

    }
}

父类

package com.polymorphism;

public class Person {
    public String name;
    public int age;
    public void say(){
        System.out.println("i am person");
    }
}

子类

package com.polymorphism;

public class Student extends Person {
    public String readclass;
    public void study(){
        System.out.println("study");
    }
    @Override
    public void say(){
        System.out.println("i am student");
    }
}

多态的不同对象对应的方法重载与继承

缺点,定义父类型参数,不能使用子类行特有功能。

package com.polymorphism;

public class PersonAct {
//    public void Action(Student C){
//        C.study();
//    }
//    public void Action(teacher T){
//        T.study();
//    }

//以上对象子类分别实现和下面直接对父类继承均可

    public void Action(Person p){
        p.study();
    }
}

调用

package com.polymorphism;

public class demo {
    public static void main(String[] args) {
        Person p1 = new Student();
        System.out.println(p1.name);
//        System.out.println(p1.readclass); //新建的需要看左边,编译和运行,所以无法调用子类中的成员变量
        p1.say(); //成员方法看右边的对象方法
        //"C:\Program Files\Java\jdk1.8.0_291\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar=50935:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_291\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_291\jre\lib\rt.jar;E:\JavaWorkSpace\project1\out\production\test;E:\JavaWorkSpace\project1\lib\kotlin-stdlib.jar;E:\JavaWorkSpace\project1\lib\kotlin-reflect.jar;E:\JavaWorkSpace\project1\lib\kotlin-test.jar;E:\JavaWorkSpace\project1\lib\kotlin-stdlib-jdk7.jar;E:\JavaWorkSpace\project1\lib\kotlin-stdlib-jdk8.jar" com.polymorphism.demo
        //null
        //i am student
        Student p2 = new Student();
        teacher t1 =new teacher();

        PersonAct p3 =new PersonAct();
        p3.Action(p1);
        Student p1n =(Student)p1; //向下转型 p1是父类person类型,强行转换成Student子类型
        System.out.println("------");
        p3.Action(p1);//向下转型
        
        p3.Action(p2);
        p3.Action(t1);

    }
}

demo 抽象类

在java中,一个没有方法体的方法应定义为抽象方法,而类中如果有抽象方法,该类必须定义成抽象类

abstract关键词修饰抽象类

package com.demoabstract;

public abstract class Animal { //abstract关键词修饰抽象类
    public abstract void eat(); //abstract关键词修饰抽象方法

}
  • 抽象类不允许直接调用

demo 接口

新建接口类,关键词与普通java类不同

接口的实现

package com.demointerface;

public class Person implements Jumping,Swining { //implements 关键词 指的是接口的实现
    public void jump(){
        System.out.println("jumping");
    }
    public void swin(){
        System.out.println("swining");
    }
}

接口

package com.demointerface;

public interface Jumping { //定义接口
    public abstract void jump();  //定义抽象方法
}
package com.demointerface;

public interface Swining {
    public abstract void swin();  //定义抽象方法
}

接口方法的调用

package com.demointerface;

public class demo {
    public static void main(String[] args) {
        Jumping j1 = new Person();
        j1.jump();
        Person p1 =new Person();
        p1.swin();
        p1.jump();
    }
}package com.demointerface;

public interface Swining {
    public abstract void swin();  //定义抽象方法
}
  • 类只能继承一个对象,但可以实现多个接口
  • 类可以在继承一个类的同时实现接口
  • 类主要在代码设计 属性和行为
  • 接口主要在代码设计 行为

形参和返回值(抽象类和接口)

demo 类名作为形式参数和返回值

调用

package com.demo187;

public class demo {
    public static void main(String[] args) {
        CatOperator op=new CatOperator();
        Cat c1=new Cat();
        op.useCat(c1);

        op.useCat(op.getCat());
    }
}

方法

package com.demo187;

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }

    public Cat getCat(){
        Cat c =new Cat();
        return c;
    }
}

demo 抽象类名作为形式参数和返回值

抽象类大致如上 需要使用新建的子类变量作为参数,父类作为返回值。

内部类

package com.demo190;

public class Outer {
    private int num =10;
    private class Inter{
//        private int num =20;
        public void show(){
//            int num = 20;
            System.out.println(num);
//            System.out.println(this.num);
        }
    }
    public void showinter(){
        Inter i= new Inter();
        i.show();
    }
}

调用

package com.demo190;

public class demo {

    public static void main(String[] args) {
        Outer o1 =new Outer();
        o1.showinter();
    }

}

局部内部类

方法

package com.demo191;

public class Outer {
    private int num=10;
    public void meth(){
        class Inner{
            public void show(){
                System.out.println(num);
            }
        }
        Inner i = new Inner();
        i.show(); //无法直接访问需要定义调用的方法
    }
}

调用

package com.demo191;

public class demo {
    public static void main(String[] args) {
        Outer o1 =new Outer();
        o1.meth();
    }
}

匿名内部类

接口

package com.demo192;

public interface Inter {
    public abstract void show(); //接口中的匿名对象必须无运行主体
}

新建方法对象及方法

package com.demo192;

public class Outer implements Inter{
    @Override
    public void show() {
        System.out.println("方法重写");
    }

    public void meth(){
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名方法");
            }
        }.show();

        Inter i =new Inter(){
            @Override
            public void show() {
                System.out.println("匿名方法");
            }
        };
        i.show();
        i.show();
    }
}

主程序调用

package com.demo192;

public class demo {
    public static void main(String[] args) {
        Outer o1=new Outer();
        o1.meth();
    }
}

Math方法 最终类

System类

利用系统函数计算程序运行时长

package com.demosysytem;

public class demo {
    public static void main(String[] args) {
        long start =System.currentTimeMillis();
        for(int i =0;i<10000;i++){
            System.out.println(i);
        }
        long end =System.currentTimeMillis();
        System.out.println((end-start));
    }
}

Object类

所有类都可继承Object ,顶级父类

toString()

equals()

尽量重写上述方法

Arrays类 操作数组的各种方法

数组排序

Arrays.sort(arr);

基本包装类-基本数据类型和字符串之间的转换

最小int到最大int范围

package com.demo201;

public class demo {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE); //-2147483648
        System.out.println(Integer.MAX_VALUE); //2147483647
    }
}

[基本数据类型和包装类](Java基础/%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%8C%85%E8%A3%85%E7%B1%BB 87e6bf8205fe4bef8c84aa4508dda951.csv)

Integer类的概述和作用

package com.demo202;

public class demo {
    public static void main(String[] args) {
        Integer i1 = new Integer(100); //数字(过时方法)
        System.out.println(i1);

        Integer i2 = new Integer("100"); //数字字符串(过时方法)
        System.out.println(i2);

        Integer i3 = Integer.valueOf("100"); //新方法
        System.out.println(i3);
    }
}

Int String 转换

Int—>String

String.valueOf() 可以接收很多种数据类型

String i3 = String.valueOf(100); //新方法
System.out.println(i3);

String —>Int

package com.demo202;

public class demo {
    public static void main(String[] args) {
//      string -> Integer -> Int
        Integer i =Integer.valueOf("100");
        int x = i.intValue();
        System.out.println(x);
//      string -> Int
        int y = Integer.parseInt("100");
        System.out.println(y);
    }
}

parse == 解析

自动装箱和拆箱

package com.demo202;

public class demo {
    public static void main(String[] args) {
        Integer i1 = new Integer(100); //数字(过时方法)
        System.out.println(i1);

        Integer i1 = 100; //自动装箱
        System.out.println(i1);

    }
}

Date 类

package com.demo202;

import java.util.Date;

public class demo {
    public static void main(String[] args) {
        Date d1 =new Date();
        System.out.println(d1); //Mon May 31 14:50:24 CST 2021
    }
}
  • SimpleDateFormat

定义日期和时间的格式

package com.demo202;

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

public class demo {
    public static void main(String[] args) throws ParseException {
        Date d1 = new Date();
        System.out.println(d1);
        SimpleDateFormat d1f =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(d1f); //java.text.SimpleDateFormat@4f76f1a0
        System.out.println(d1f.format(d1)); // d1f.format(d1)为string类型 2021-05-31 15:07:56

        String strdate = "2021-05-31 15:07:56";
//      Date d2 = d1f.parse(strdate); //此处需处理抛出的异常,throws ParseException 或者try/catch环绕
        Date d2 = d1f.parse(strdate);
        System.out.println(d2);
    }
}

Calendar类 日历类

异常

Throwable所有(Error/异常)的超类

![/images/JavaBase/Untitled 5.png](/images/JavaBase/Untitled 5.png)

异常处理demo 多个方法

package com.demotry;

public class demo {
    public static void meth() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[30]); //运行时异常
        }catch (ArrayIndexOutOfBoundsException err){
            System.out.println("索引不存在"); //提示
            err.printStackTrace(); //抛出异常并继续执行后续代码
            System.out.println(err.getMessage()); //30 返回出现异常的内容
        }
    }

    public static void main(String[] args) {
        System.out.println("start");
        meth();
        System.out.println("finish");
    }
}

编译异常/运行时异常

throws 谁调用谁处理异常,尽量使用 try/catch处理异常

自定义异常类

package com.myexception;

public class myexception extends Exception{
    public myexception(){}
    public myexception(String message){
        super(message);
    }
}

继承自定义异常的异常处理方法

package com.myexception;

public class dealdata {
    public void checkInt(int score) throws myexception{
        if (score<0){
            String msg ="不为正数";
            throw new myexception(msg);
        }else{
            System.out.println("是正数");
        }
    }
}

main函数

package com.myexception;

public class demo {
    public static void main(String[] args) {
        int num = -1;
        dealdata data =new dealdata();
        try {
            data.checkInt(num);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

集合进阶

Collection

![/images/JavaBase/Untitled 6.png](/images/JavaBase/Untitled 6.png)

package com.collectiondemo;

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

public class demo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("test");
        c.add("hello");
        System.out.println(c.toString());
    }
}

![/images/JavaBase/Untitled 7.png](/images/JavaBase/Untitled 7.png)

collection默认重写了tostring方法

![/images/JavaBase/Untitled 8.png](/images/JavaBase/Untitled 8.png)

Collection 遍历

Iteratior:迭代器

迭代器常用方法

next() 获取下一个元素

hasNext() 判断下是否有下一个元素,返回boolean值

package com.collectiondemo;

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

public class demo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("test");
        c.add("hello");
        c.add("hello1");
        c.add("world");
        System.out.println(c.toString()+c.size());

        Iterator<String> it =c.iterator();
//        it.hasNext();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

List 集合

有序,存储数据可重复

package com.demolist;

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

public class demo {
    public static void main(String[] args) {
        List<String> li =new ArrayList<String>();
        li.add("test");
        li.add("tes1t");
        li.add("tes21t");
        li.add("te21st");
        System.out.println(li);

        //使用迭代器
        Iterator<String> it =li.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //使用构造方法
        System.out.println(li.get(0));
        li.add(0,"gogogo");
        System.out.println(li.get(0));
        //修改元素
        li.set(0,"gogogo");
    }
}

并发修改异常

并发异常原因可能是使用while循环改用for i++ 循环

ListIterator 列表专用迭代器

允许从任意方向遍历列表的迭代器

并可以在列表在遍历时修改数据,解决前面的并发修改异常问题

增强for循环包装的是一个迭代器

package com.demolist;

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

public class demo {
    public static void main(String[] args) {
        List<String> li = new ArrayList<String>();
        li.add("test");
        li.add("tes1t");
        li.add("tes21t");
        li.add("te21st");
        System.out.println(li);
        for (String i : li) {
            System.out.println(i);
        }

        int[] lis = {1, 5, 3, 2};
        for (int i : lis) {
            System.out.println(i);
        }
    }
}

数据结构

  • 栈 先进后出 后进先出
  • 队列 先进先出 后进后出
  • 数组 通过索引定位,查询效率高;删除数据后,后续数据要前移,删除效率低;添加数据,需要把数据向后移动,添加效率极低
  • 链表 是一种增删快并查询慢的数据模型,对比数组

List集合的子类的特点

Arraylist 底层是数组 查询快 增删慢

LinkedList 底层是链表 增删快 查询慢

Set 集合

不包含重复元素的结合,继承自Collection,不带有索引方法,不能使用普通for遍历

底层可能是hashset,对集合的迭代顺序不做任何保证,可重复往集合添加,但数据唯一并不重复

package com.demoset;

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

public class demo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("test");
        set.add("test2");
        set.add("test1");
        for(String s:set){
            System.out.println(s);
        }
    }
}

HashCode

new 对象 不同对象的hashcode不同

相同字符串的hashcode相同

LinkedHashSet

底层数据结构是 hash表和链表

具有可预测的迭代次序

由hash表保证唯一不重复

TreeSet集合

特点:元素有序(按照自然排序/指定排序);没有索引,不能使用普通for循环;不包含重复元素。

package com.demohashcode;
import java.util.TreeSet;

public class Student {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> tr = new TreeSet<Integer>(); 
				//集合存储的是引用类型,使用基本类型的包装类类型
        //添加元素
        tr.add(10);
        tr.add(59);
        tr.add(33);
        tr.add(23);
        for (Integer i :tr){
            System.out.println(i);
        }
    }
}

Comparable

继承Comparable接口 重写compareTo()进行排序

泛型 提前定义类型

package com;

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

public class DemoOC {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("test");
        c.add("test");
        c.add("user");
        c.add("test");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj); //遍历object对象

            String s = (String) it.next(); //强行转换成String类型
            System.out.println(s);
        }
    }
}

可变参数

package com.demo255;

public class demo {
    public static void main(String[] args) {
        int sum1 = sum(1, 54, 5, 2);
        System.out.println(sum1);
    }

    public static int sum(int b,int... a) {
        int sum = 0;
        for (int i : a) {
            sum = sum + i;
        }
        return sum;
    }
}

可变参数要放在最后

视频跳过246-271

File

package com.demo272;

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

public class demo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("E:\\config.yaml");
        System.out.println(f1);

        File f2 = new File("E:\\","config.yaml");
        System.out.println(f2);

        File f3 = new File("E:\\");
        File f4 = new File(f3,"config.yaml");
        System.out.println(f4);

//        f4.createNewFile()
        System.out.println(f4.createNewFile());
    }
}

文件创建需抛出异常

递归

方法定义中调用方法本身,递归一定要写条件语句来终止递归

package com.demodigui;

public class demo {
    public static void main(String[] args) {
        System.out.println(f(18));
    }

    public static int f(int n) {
        if (n <= 2) {
            return 1;
        }
        n = f(n - 1) + f(n - 2);
        return n;
    }
}

递归文件遍历-输出目录下所有文件

package com.demodigui;

import java.io.File;

public class demo {
    public static void main(String[] args) {
        File filelo =new File("E:\\");
        GetAllPathFile(filelo);

    }
    public static void GetAllPathFile(File path){
       File[] fileArray= path.listFiles();
       if (fileArray !=null ){
           for(File F:fileArray){
               if (F.isDirectory()){
                   GetAllPathFile(F);
               }else{
                   System.out.println(F.getAbsolutePath());
               }
           }
       }
    }
}

IO流

字节流

package com.demooutputstream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class demo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\test.txt",true);//true是指追加写入
        //调用功能创建文件
        //创建字节输出流对象
        //字节输出流指向文件
        fos.write(0x6f);

        fos.write("text\ntest".getBytes(StandardCharsets.UTF_8));
        //写入数据
        fos.close();
        //释放资源
    }
}

![/images/JavaBase/Untitled 9.png](/images/JavaBase/Untitled 9.png)

文件写入时异常处理

package com.demooutputstream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class demo {
    public static void main(String[] args) {
        FileOutputStream fos = null;//初始化
        try {
            fos = new FileOutputStream("E:\\test.txt", true); //追加写入
            fos.write("text\ntest".getBytes(StandardCharsets.UTF_8));
            //写入数据
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) { //判断fos是否为null,提升健壮性 
                try {
                    fos.close();
                    //释放资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件复制字节流

![/images/JavaBase/Untitled 10.png](/images/JavaBase/Untitled 10.png)

字节缓冲流

package com.demobufferstream;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class demo {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\test.txt"));
        bos.write("hello\n".getBytes(StandardCharsets.UTF_8));
        bos.close();
    }
}

标准输入输出流

实际使用使用Scanner包装类

package com.demoinputstream;

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

public class demo {
    public static void main(String[] args) throws IOException {
        InputStream is =System.in;
        InputStreamReader isr =new InputStreamReader(is);//字节流转换成字符流
        BufferedReader br =  new BufferedReader(isr);//字符流转换成缓冲区流
        System.out.println(br.readLine()); //缓冲流有readLine方法,可以读取一行数据
    }
}

字节打印流(不含输出方法)

可以直接打印输出数据

package com.demoprintstream;

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

public class demo {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream ps =new PrintStream("D:\\test.txt");
        ps.println("test"); //test.txt test
        ps.close();
    }
}

对象序列化流(lesson 318)

使用流实现对象持久存储,如果是网络套接字流,可以在另一个主机或进程读取/重构对象

调用序列化对象

package com.demo317;

import java.io.*;

public class demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化
				ObjectOutputStream oss = new ObjectOutputStream(new FileOutputStream("E:\\test.txt"));
        Student s = new Student("lilei", 22);
        oss.writeObject(s);
        oss.close();
				//反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\test.txt"));
        Object obj = ois.readObject(); //向下转型
				ois.close();
        Student s1 = (Student)obj;
        System.out.println(s1.getAge()+s1.getName());
    }
}

序列化对象做修改后反序列化会报错

反序列化时序列做了改变,需要将所有可序列化类显试申明VersionID值

package com.demo317;

import java.io.Serializable;

public class Student implements Serializable { //序列化标识接口,无需重写方法
		private static final long serialVersionUID =41L; //声明序列化ID值
    private String name;
    private transient int age; //transient 修饰的对象不参与序列化,还原后为默认值

    public Student() {
    }

    public Student(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;
    }

}

Properties特有方法

导出导入配置文件

package com.demoproperties;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class demo {
    public static void main(String[] args) throws IOException {
        Properties prop =new Properties();
        prop.setProperty("treads","5");
        prop.setProperty("timeout","57");
        prop.setProperty("timeout","43");
        System.out.println(prop.getProperty("timeout"));

        System.out.println(prop);
        //{timeout=43, treads=5}

        prop.store(new FileOutputStream("E:\\test.txt"),"null");
        /*
        #null
        #Tue Jun 01 20:02:24 CST 2021
        timeout=43
        treads=5
        */

    }
}

多线程

Tread类 线程类

调用类

package com.demoTreads;

public class demo {
    public static void main(String[] args) {
        Mytread tr1 =new Mytread();
        Mytread tr2 =new Mytread();
//        tr1.run();//这种方式并不是启动线程
        tr1.setName("tr1"); //设置线程名
        tr1.setPriority(10); //设置线程优先级,默认为5,数字越大优先级越高 1-10
        tr1.start();
        tr2.start();
    }
}

线程类

package com.demoTreads;

public class demo {
    public static void main(String[] args) {
        Mytread tr1 =new Mytread();
        Mytread tr2 =new Mytread();
//        tr1.run();//这种方式并不是启动线程
        tr1.setName("tr1"); //设置线程名
        tr1.setPriority(10); //设置线程优先级,默认为5,数字越大优先级越高 1-10
        tr1.start();
        try {
            tr1.join(); //等待此线程结束后才运行其他线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tr2.start();
    }
}

线程调度-抢占式调度模型

线程优先级设置查看上面代码,线程优先级高只是获取到cpu优先的几率高

线程控制


Runnable接口

网络编程

UDP

通过DatagramPacket传输数据,DatagramSocket UDP

接收端

package com.demoudp;

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

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket dq = new DatagramSocket(8081);
        byte[] data = new byte[1024]; //定义1024的数组
        DatagramPacket dp = new DatagramPacket(data, data.length); //创建数据包
        dq.receive(dp);
        byte[] datalo = dp.getData(); //获取data
        int reallenth = dp.getLength(); //获取实际接收数据的长度
        String str =new String(datalo,0,reallenth);
        System.out.println(str);
        dq.close();
    }
}

发送端

package com.demoudp;

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class Senddemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds =new DatagramSocket();
        byte[] by = "hello".getBytes(StandardCharsets.UTF_8);
        DatagramPacket dp =new DatagramPacket(by,by.length);
        InetAddress address = InetAddress.getByName("localhost");
        dp.setAddress(address);
        dp.setPort(8081);
        ds.send(dp);
        ds.close();
    }
}

TCP发送接收数据

Client

package com.demosocket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class Client {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("localhost",9999); //创建客户端
        OutputStream os=s.getOutputStream(); //获取输出流
        os.write("hello".getBytes(StandardCharsets.UTF_8)); //写数据

        //接收reply
        InputStream is = s.getInputStream();
        byte[] data =new byte[1024];
        int lenth = is.read(data); //获取字节数组和字节长度
        String str = new String(data,0,lenth);
        System.out.println(str);

        s.close();
    }
}

Server

package com.demosocket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.nio.charset.StandardCharsets;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket s =new ServerSocket(9999); //设置监听端口

        while(true){InputStream is = s.accept().getInputStream(); //需要使用accept方法
            byte[] data =new byte[1024];
            int lenth = is.read(data); //获取字节数组和字节长度
            String str = new String(data,0,lenth);
            System.out.println(str);

            //返回信息
            OutputStream os=s.accept().getOutputStream(); //需要使用accept方法获取输出流
            os.write("reply".getBytes(StandardCharsets.UTF_8)); //写数据
            }
//       s.close();
    }
}

Lambda表达式

完成匿名内部类

package com.demolambda;

public class demo {
    public static void main(String[] args) {
        /*
        new Thread(new TestFunc(){
            public void run(){
                System.out.println("test");
            }
        }).start();
        */ //已弃用
        new Thread(()->{
            System.out.println("test");
        }).start();
    }
}
格式(形式参数)->{代码块}

=

comments powered by Disqus