javase笔记

B64A-消闲

已于 2022-04-08 22:16:50 修改

阅读量893

点赞数

分类专栏：笔记文章标签： java 开发语言

于 2022-03-09 22:03:33 首次发布

本文链接：https://blog.csdn.net/weixin_56851586/article/details/123388802

版权

笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

java注意事项

方法由对象调用

见名知意，this关键字！

封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的**getXxx()/setXxx()**方法

好处：提高了代码的安全性和复用性

 //创建一个学生信息类
public class student {
    //成员变量
    private String name;
  private int age;//设置private关键字，为了防止直接通过对象名访问成员变量可能会造成的数据安全隐患
//提供成员方法（get、set）
      public void setAge(int age)//age为局部变量
      {
            if(0<n&&n>100)
                this.age=age;//this修饰的变量用于指代成员变量。解决局部变量和成员变量同名
            else
                System.out.println("输入的年龄有误");
      }

      public int getAge(){
          return  age;
      }
    
    
    public void setName(String name)
      {
           this.name=name;
      }
    public String getName(){
        return  name;
    }
    
    
    
      //创建show方法
      public void show(){
          System.out.println(name+","+age);
      }
      //有感觉
      private void love(){
          System.out.println("黄婧");
      }
  }

构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dQ6MmhOm-1646834555133)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_15-00-44.png)]

方法名为类名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T9MC7Nj8-1646834555134)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-28_14-04-30.png)]

/*
创建学生类
*/
public class student {
    //成员变量
  private String name;
  private int age;

/*
无参数构造方法
*/
   public student(){}
/*
带参数构造方法
*/ 
  public student(String name,int age){
      this.name=name;
      this.age=age;
  }

快捷键

//ctrl+/--为选中快捷注释
//ctrl+alt+v//--自动添加接收数据的变量
//alt+Fn+ins//--快捷创建构造方法及get/set方法，方法重写
//长按shift+左键最下一行全选
//psvm+回车快速生成 public static void main(String[] args){}
//ctrl+b---访问源码
//shift+Tab--将代码往左移
//alt+鼠标左键--整列编辑
//alt+enter--异常抛出
//ctrl+alt+l//格式化代码

String

字符串效果上相当于字符数组（char[]),但底层原理是字节数组（byte[])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmhN0iKk-1646834555135)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-28_16-20-02.png)]

遍历字符串

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rhsbw9jS-1646834555135)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_14-17-59.png)]

for(int i=0;i<s.length();i++)
{
    s.charAt(i);  //就是指定索引处的字符值
}

字符串比较

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQ1fe5uV-1646834555135)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_14-22-35.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p64SDRNz-1646834555136)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_14-24-04.png)]

拼接字符串

直接用String类进行拼接，过于浪费空间

package string;

public class stringpj {
    public static void main(String[] args){
        char[] arr={'a','b','c'};
      String s=arrayToString(arr);
      System.out.println("s:"+s);
    }
    public static String arrayToString(char[]  arr) {
        String s = "";
        s += "[";
        for (int i = 0; i < arr.length; i++) {
            if (i  == arr.length-1)
                s += arr[i];
            else
            {s += arr[i];
            s += ", ";}
        }
        s += "]";
        return s;
    }
}

字符串拼接的理解

StringBuilder

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTkIqWoB-1646834555136)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_15-53-59.png)]

string内容不可变

stringBuilder内容可变

String类是不可变类，即字符串值一旦初始化后就不可能改变。StringBuffer是可变字符串类，类似String的缓冲区，可以修改字符串的值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFDmJloK-1646834555137)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_16-00-19.png)]

以后就用这种方法来对字符串的操作

使用
链式编程（因为append(任意类型)返回对象本身）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6EPkyS8U-1646834555137)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_16-06-38.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WcF7DUN0-1646834555138)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_16-16-15.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uOXZ6UWj-1646834555139)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_16-15-37.png)]

匿名对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1zG3oxI9-1646834555139)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-10-30_17-03-56.png)]

return new StringBuilder(s).reverse().toString();//中的new StringBuilder(s)及new StringBuilder(s).reverse().toString()为匿名对象

集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YQYfWwxp-1646834555140)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-04_18-19-48.png)]

集合类特点：提供一种存储空间可变存储模型，存储的数据容量可以发生改变

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nsjuSRB3-1646834555140)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-04_18-24-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9UDJfvhm-1646834555140)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-04_18-30-02.png)]

//创建一个空集合
 ArrayList<类型> array=new ArrayList<>();

继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dsu1YOF-1646834555141)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-04_23-15-55.png)]

创建一个父类

public class Fu{
        public void sd(){
            System.out.println("sd方法已调用");
        }
}

创建一个子类

public class zi extends Fu {   
    public void sb(){
        System.out.println("sb方法已调用");
    }
}

测试

public class jic {
    public static void main(String[] args){

        Fu d=new Fu();
        d.sd();

        zi b=new zi();
        b.sb();
        b.sd();

    }
}

结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BdmxHqxM-1646834555141)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_18-23-26.png)]

继承的好处和弊端

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3fIyVxvN-1646834555141)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_18-30-04.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7bPLc1k5-1646834555142)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_18-35-30.png)]

先在方法内寻找被访问的变量->在到子类成员变量中寻找->再到父类成员变量寻找->没有则报错（不考虑父亲的父亲）

super

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8AeLzJM-1646834555142)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_18-43-52.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efP32Onc-1646834555142)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_18-53-36.png)]

重点：子类一定先访问父类的无参的构造方法

所以如果想要用带参构造方法创建对象，就要在子类中创建无参和带参构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tqmzPhd6-1646834555142)(D:\java图\Snipaste_2021-11-06_21-07-08.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OcE5nIi2-1646834555143)(D:\java图\Snipaste_2021-11-06_21-05-56.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-upZYOtE3-1646834555143)(D:\java图\Snipaste_2021-11-06_21-04-02.png)]

方法重写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5AaIlnNH-1646834555143)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_19-18-43.png)]

public class zi extends Fu {   
    
    @Override     //有误则重写方法的方法声明有错
    public void sb(){
        System.out.println("sb方法已调用");
    }
}

注意事项

重写函数访问级别限制不能比原函数高。举个例子：如果父类方法声明为公有的，那么子类中的重写方法不能是私有的或是保护的。

只有被子类继承时，方法才能被重写。

方法定义为final，将导致不能被重写。

一个方法被定义为static，将使其不能被重写，但是可以重新声明。

一个方法不能被继承，那么也不能被重写。

和父类在一个包中的子类能够重写任何没有被声明为private和final的父类方法。

和父类不在同一个包中的子类只能重写non-final方法或被声明为public或protected的方法。

package

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBjJHj55-1646834555143)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_20-39-11.png)]

cn.blp 就是cn文件夹里有个blp文件夹

导包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OY54K3G8-1646834555144)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_20-43-41.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMwZwC1S-1646834555144)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_20-44-01.png)]

就像Scanner一样，需要导包

权限修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZEZD4jKD-1646834555144)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_20-52-23.png)]

打钩为可以访问

但在不同包中都需要导包

Final

final关键字是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点

修饰方法:表明该方法是最终方法,不能被重写
修饰变量:表明该变量是常量，不能再次被赋值
修饰类:表明该类是最终类,不能被继承

final修饰局部变量

变量是基本类型: final 修饰指的是基本类型的数据值不能发生改变
变量是引用类型: final 修饰指的是引|用类型的地址值不能发生改变,但是地址里面的内容是可以发生改变的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iYpkskRW-1646834555144)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_21-09-54.png)]

s.age可以修改但不能给s重新创建一个地址

static

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZFApwtNB-1646834555144)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_21-22-56.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vlSBeBI0-1646834555145)(C:\Users\99456\Desktop\新建文件夹\Snipaste_2021-11-05_21-23-22.png)]

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

主方法为静态的成员方法只能访问静态成员，所以在这个类中的方法用static修饰

多态

前提就是继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-byNKMJVt-1646834555145)(D:\java图\Snipaste_2021-11-06_17-05-10.png)]

有父类引用指向子类对象

动物 animal=new 猫();

有继承

public class cat extends animal{}

多态中成员访问特点

左-父类，右-子类

成员变量:编译看左边，执行看左边

成员方法:编译看左边（看父类中是否存在该方法），执行看右边（看子类重写后的方法）

父类

public class animal{
    private int age=18；
    
    public void eat(){
        System.out.println("动物吃东西")；
    }
}

子类

public class cat extends animal{
    private String name="猫"；
    private int age=20；
    //方法重写
    public void eat(){
        System.out.println("猫吃鱼")；
    }
    public void play(){
        System.out.println("猫玩球")；
    }
}

测试类

public class demo{
    public static void main(String[] args){
        animal s=new cat();
        //成员变量
       System.out.println(s.age)；     //输出18
！           System.out.println(s.name)；//报错，因为父类中没有name这个成员变量
          
        //成员方法
        s.eat();  //输出：猫玩球。
!        s.play();//报错，因为父类中没有play()这个成员方法

为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而成员变量没有

多态的好处和弊端

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cwj7AkiR-1646834555145)(D:\java图\Snipaste_2021-11-06_17-55-04.png)]

动物类

public class animal{
    
    public void eat(){
        System.out.println("动物吃东西");
    }
   public void play(){
        System.out.println("动物爱玩");
    }
    public void like(){
        System.out.println("动物喜欢运动");
    }
}

猫类

public class cat extends animal{

//方法重写
public void eat(){
        System.out.println("猫吃鱼");
        }
public void play(){
        System.out.println("猫玩球");
        }
    public void like(){
        System.out.println("猫喜欢睡觉");
    }

        }

狗类

public class dog extends animal{
       
        //方法重写
        public void eat(){
            System.out.println("狗吃骨头");
        }
        public void play(){
            System.out.println("狗接飞盘");
        }
        public void like(){
            System.out.println("狗喜欢跑步");
        }

    }

动物操作类

public class useAnimal {
    public void use(animal a){
        // animal a=new cat();
       // animal o=new dog();
        a.eat();
        a.play();
        a.like();
    }
}

测试类1

public class demo {
    public static void main(String[] args) {
        useAnimal ao=new useAnimal();
        cat c=new cat();
        ao.use(c);
        dog d=new dog();
        ao.use(d);
    }
}

如果不创建操作类

测试类2

 public class demo {
    public static void main(String[] args) {
        dog a=new dog();
        cat o=new cat();
        
        a.like();
        a.eat();
        a.play();
        
        o.eat();
        o.play();
        o.like();
    }
}

每增加一种动物都要创建一个对象和调用多个方法(前提调用的方法相同），更麻烦。

向上转型

解决不能使用子类的特有功能

animal o=new dog();//向上转型

dog a=(dog)o;//向下转型  可以不用在创建一个新的dog对象

抽象类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUv6aCJA-1646834555146)(D:\java图\Snipaste_2021-11-06_18-54-13.png)]

1.2抽象类的特点
抽象类和抽象方法必须使用abstract关键字修饰
public abstract class类名书
public abstract void eat());

public abstract class animal{
    public abstract void eat();
}

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化----即不能创建对象

animal a=new animal();//错误

抽象类如何实例化呢?参照多态的方式，通过子类对象实例化,这叫抽象类多态

public class cat extends animal{}

抽象类的子类

要么重写抽象类中的所有抽象方法。(强制子类重写该方法)

要么是抽象类。即用abstract 修饰子类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXUdPPHQ-1646834555146)(D:\java图\Snipaste_2021-11-06_19-20-59.png)]

接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-du4Ey9OL-1646834555147)(D:\java图\Snipaste_2021-11-06_19-47-14.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCY1OXGR-1646834555147)(D:\java图\Snipaste_2021-11-06_19-52-59.png)]

接口成员特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aZ9c1UXM-1646834555147)(D:\java图\Snipaste_2021-11-06_20-16-35.png)]

//成员变量
public static final int age=19;
等于
int age=19;

一个类如果没有父类，默认继承Object类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2WRNzALx-1646834555147)(D:\java图\Snipaste_2021-11-06_20-20-27.png)]

实现/子类父类接口

接口和抽象类的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9gMrvV4G-1646834555148)(D:\java图\Snipaste_2021-11-06_21-23-32.png)]

继承只能单继承

eg:门的功能有开，关，有的门能报警
    如果单独用一个抽象类或接口来对这三种行为抽象，那么门必须都强制具备开关和报警，但有的门没有
    如果用三个抽象类来对这三种行为抽象，则无法继承三个
    最好的方法是开关用抽象类，报警用接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wO0lHS7j-1646834555148)(D:\java图\Snipaste_2021-11-06_21-36-22.png)]

类名作为形参和返回值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DQEZx4uJ-1646834555148)(D:\java图\Snipaste_2021-11-07_19-26-46.png)]

狗类

public class dog {
    public void eat(){
            System.out.println("狗吃骨头");
        }
}

操作类

public class usedog{
   public void udog(dog c){//作为形参
       //dog d=new dog();----创建dog对象，只有对像才能调用方法
       d.eat();
   }
    
  public dog getdog(){  //作为返回值
      dog d=new dog();
      return d;
  }  
}

测试类

public class demo {
    public static void main(String[] args) {
        usedog a=new usedog();
        dog d=new dog();
        a.udog(d);   

        dog o=a.getdog();
        d.eat;
    }
}

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w4o4UVDF-1646834555148)(D:\java图\Snipaste_2021-11-07_19-30-19.png)]

可以理解为抽象类名作为形参和返回值时要用到抽象多态创建一个子类或使用匿名内部类

接口类名作为形参和返回值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qFgUPOVu-1646834555148)(D:\java图\Snipaste_2021-11-07_19-56-53.png)]

和抽象类的用法类似

内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQEQNEmf-1646834555149)(D:\java图\Snipaste_2021-11-07_20-38-22.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1clvGVsi-1646834555149)(D:\java图\Snipaste_2021-11-07_20-37-37.png)]

成员内部类-----在类的成员变量位置—如图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qBK5205m-1646834555149)(D:\java图\Snipaste_2021-11-07_20-48-29.png)]

内部类一般以private修饰，不让外界访问，那么如何使用内部类呢？那就在外部类中创建一个方法，创建一个内部类的方法，在访问内部类的方法。而外界使用时只需创建外部类对象在调用方法。

如果是public修饰的呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O08VpjGA-1646834555150)(D:\java图\Snipaste_2021-11-07_20-44-25.png)]

局部内部类-----在类的局部位置（成员方法）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iGeJkBdO-1646834555150)(D:\java图\Snipaste_2021-11-07_22-07-03.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SqUN4axB-1646834555150)(D:\java图\Snipaste_2021-11-07_22-07-22.png)]

匿名内部类

特殊的局部内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDXFKPXr-1646834555150)(D:\java图\Snipaste_2021-11-07_22-10-48.png)]

注意他是一个对象

别忘加“；”

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uoCrJh6q-1646834555150)(D:\java图\Snipaste_2021-11-07_22-17-55.png)]

此Inter为一个接口，i用来接收此对象的数据（new Inter()）

匿名内部类在开发中的使用(免去创建子类或实现)

接口

public interface jumpping {
    void jump();
}

操作类

public class use {
    public void method(jumpping j){
        j.jump();
    }
}

测试类

public class demo {
    public static void main(String[] args) {
            use u=new use();
            u.method(new jumpping() {
                @Override
                public void jump() {
                    System.out.println("匿名内部类");
                }
            });
    }
}

不用匿名内部类

接口

public interface jumpping {
    void jump();
}

操作类

public class use {
    public void method(jumpping j){
        j.jump();
    }
}

实现

public class zi implements jumpping(){
    
    public void jump() {
                    System.out.println("接口多态");
                } 
}

测试类

public class demo {
    public static void main(String[] args) {
            use u=new use();
            zi d=new zi();
        u.method(d);
    }
}

接口作为形参，为了使用接口里的jump方法，于是用的匿名内部类，不必再创建一个实现类

Math类

该类为final类所以无子类

方法都被static修饰所以不需要创建对象，用类名调用即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-usymxJjP-1646834555150)(D:\java图\Snipaste_2021-11-08_09-19-07.png)]

System.out.println(Math.abs(-88));//取绝对值

System.out.println((int)Math.random()*100+1);//取0到100的随机整数

System类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CjJVDOsI-1646834555150)(D:\java图\Snipaste_2021-11-08_09-33-37.png)]

 System.exit(0);//JVM退出--虚拟机退出

//计算程序运行的时间
long l = System.currentTimeMillis();
        for (int i=0;i<10000;i++){
            System.out.println(i);

        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l);

 System.out.println(System.currentTimeMillis()*1.0/1000/6024);//计算1970年到当前时间天数

Object中的toString()方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1bLNSsgr-1646834555151)(D:\java图\Snipaste_2021-11-08_22-15-10.png)]

也就是说子类都可以使用toString()方法,建议子类重写该方法，如何重写呢？ait+fn+ins自动生成

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IvnHv79P-1646834555151)(D:\java图\Snipaste_2021-11-08_22-30-28.png)]

更直观。

Object中的equals()方法

子类都可以使用equals()方法,建议子类重写该方法，如何重写呢？ait+fn+ins自动生成

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Fu fu = (Fu) o;

        if (age != fu.age) return false;
        return name != null ? name.equals(fu.name) : fu.name == null;
    }

student s1=new student();
s1.setAge(18);
s1.setName("blp");

student s2=new student();
s2.setAge(15);
s2.setName("blx");

//比较s1和s2是否内容相等
System.out.println(s1.equal(s2));//如果不重写使用此方法比较的是地址，重写后才比较的是内容

冒泡法

java中的数组空间不可变i+1容易越界，c语言则不会
public class bijjiao {
    public static void main(String[] args) {
        int[] arr={12,32,11,45,56,77};
        System.out.println("排序前arr="+shuchu(arr));

        for (int j=0;j<arr.length;j++)
        for (int i=0;i<arr.length-1;i++){      //-1的原因
            if (arr[i]>arr[i+1]){               //java中的数组空间不可变i+1容易越界，c语言则不会
                int sum=arr[i+1];
                arr[i+1]=arr[i];
                arr[i]=sum;
            }
        }
        System.out.println("排序前arr="+shuchu(arr));

    }

//将数组转换为字符串
    public static String shuchu(int[] arr){
        StringBuilder s=new StringBuilder();
        s.append("[");
        for (int i=0;i<arr.length;i++){
            if(i!=arr.length-1){
                s.append(arr[i]);
                s.append(",");
            }
            else {s.append(arr[i]);
                s.append("]");}
        }
        String ss=s.toString();
        return ss;
    }
}

#include<stdio.h>
main(){
	int a[]={12,13,21,32,11,14};
	int i,m,j;
	for(j=0;j<6;j++)
	for(i=0;i<6;i++){
		if(a[i]>a[i+1]){
		    m=a[i+1];
			a[i+1]=a[i];
			a[i]=m;	
		}
	}
	for(i=0;i<6;i++)
	{
		printf("%d\n",a[i]);
	}
}

arrays类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YwkvVEK2-1646834555152)(D:\java图\Snipaste_2021-11-08_23-37-36.png)]

于是上述冒泡法可写成

import java.util.Arrays;
public class bijjiao {
    public static void main(String[] args) {
        int[] arr={12,32,11,45,56,77};
        System.out.println("排序前arr="+ Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("后arr="+Arrays.toString(arr));}
}

基本类型包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dBL8pRa5-1646834555152)(D:\java图\Snipaste_2021-11-08_23-51-32.png)]

简单来说将基本类型进行包装可以定义更多的功能方法操作该数据，方便

Integer类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GKSS9Ngy-1646834555152)(D:\java图\Snipaste_2021-11-08_23-53-49.png)]

创建对象

        Integer s1=Integer.valueOf(100);
        System.out.println(s1);
        Integer s2=Integer.valueOf("100");
        System.out.println(s2);

Integer.parsrInt()返回的是int类型，Integer.valueOf()返回的是Integer，将String转换为int类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qOIRm7Ny-1646834555153)(D:\java图\Snipaste_2021-11-09_00-37-42.png)]

字符串中字符排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iN5cfsns-1646834555153)(D:\java图\Snipaste_2021-11-10_11-53-29.png)]

split(String ergex)中的regex为字符之间的隔开符号，如这里用split(" “);有的用split(”,");

自动装箱和拆箱

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AK3n2Jp0-1646834555153)(D:\java图\Snipaste_2021-11-10_12-15-04.png)]

简化了装箱拆箱的操作

//进行不为null的判断
if(i!=null){}

Date

构造方法

import java.util.Date;
public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();       //当前时间
        System.out.println(d);

        long d1=1000*60*60;
        Date d2=new Date(d1);
        System.out.println(d2);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1vlFZhK-1646834555153)(D:\java图\Snipaste_2021-11-10_12-57-36.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yhsgvE52-1646834555154)(D:\java图\Snipaste_2021-11-10_12-58-10.png)]

本来是1点但是这不是北京时间，所以有时差。在date中重写了toString()方法输出时调用了toString()方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ARBPJRhb-1646834555154)(D:\java图\Snipaste_2021-11-10_13-02-36.png)]

import java.util.Date;

public class bijjiao {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d.getTime());
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365+"年");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDTNNXS1-1646834555155)(D:\java图\Snipaste_2021-11-10_13-16-05.png)]

SimpleDateFormat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UnB6aS2N-1646834555155)(D:\java图\Snipaste_2021-11-11_20-48-15.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5aRcMNVF-1646834555155)(D:\java图\Snipaste_2021-11-11_20-47-42.png)]

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

public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();
        SimpleDateFormat s=new SimpleDateFormat();//默认模式
        String v = s.format(d);
        System.out.println(v);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LhVCFuEQ-1646834555156)(D:\java图\Snipaste_2021-11-11_21-02-46.png)]

给定模式

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

public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();
        SimpleDateFormat s=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
        String v = s.format(d);
        System.out.println(v);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FvnG1ZIe-1646834555156)(D:\java图\Snipaste_2021-11-11_21-07-45.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uLtKJiAJ-1646834555156)(D:\java图\Snipaste_2021-11-11_20-49-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dbv8gEx2-1646834555156)(D:\java图\Snipaste_2021-11-11_21-11-34.png)]

格式化如上代码

解析

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

public class bijjiao {
    public static void main(String[] args) throws ParseException {
        String s="2021-11-11 21:14:00";
        SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //格式要和上面字符串一样
        Date v = ss.parse(s);
        System.out.println(v);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lGNkTD3z-1646834555156)(D:\java图\Snipaste_2021-11-11_21-42-54.png)]

时间工具类

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

public class Datetool {

    private Datetool() {}

    public static String DateToString(Date date,String p){
        SimpleDateFormat d=new SimpleDateFormat(p);
        String s = d.format(date);
        return s;
    }
    public static Date StringToDate(String b,String p) throws ParseException {
        SimpleDateFormat d=new SimpleDateFormat(p);
        Date s = d.parse(b);
        return s;
    }
}

直接用类名调用方法

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

public class Datedemo {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        String p="yyyy年MM月dd日 HH:mm:ss";
        String z = Datetool.DateToString(d, p);
        System.out.println(z);

        String a="2022-11-22 22:22:00";
        String e="yyyy-MM-dd HH:mm:ss";
        Date w = Datetool.StringToDate(a, e);
        System.out.println(w);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QMJAiLT9-1646834555157)(D:\java图\Snipaste_2021-11-11_23-37-40.png)]

Calendar类(抽象类)

也叫做日历类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-csg0NU53-1646834555157)(D:\java图\Snipaste_2021-11-11_23-59-34.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wvLTVYeU-1646834555157)(D:\java图\Snipaste_2021-11-11_23-53-03.png)]

构造方法，因为是抽象类所以要创建一个子类来构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XUmwh2Ru-1646834555157)(D:\java图\Snipaste_2021-11-12_00-11-31.png)]

import java.util.Calendar;

public class Calenda {
    public static void main(String[] args) {
        Calendar d = Calendar.getInstance();
        
        int year = d.get(Calendar.YEAR);
        int mouth = d.get(Calendar.MARCH)+1;//月份要加一,从0开始
        int date = d.get(Calendar.DATE);

        System.out.println(year + "年" + mouth + "月" + date + "日");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-syfvM2Lm-1646834555158)(D:\java图\Snipaste_2021-11-12_01-06-11.png)]

d.add(Calendar.DATE,-3);//往后减3天，查看前三天的日期

设置日期

import java.util.Calendar;

public class Calenda {
    public static void main(String[] args) {
        Calendar d = Calendar.getInstance();

        d.set(1900,12,11);
        int year = d.get(Calendar.YEAR);
        int mouth = d.get(Calendar.MARCH)+1;
        int date = d.get(Calendar.DATE);
        System.out.println(year + "年" + mouth + "月" + date + "日");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1KzTUUX-1646834555158)(D:\java图\Snipaste_2021-11-12_01-13-04.png)]

求某一年的2月份有几天

这一年的3月1号前一天就是2月份的天数

mport java.util.Calendar;
import java.util.Scanner;

public class Calenda {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入年份：");
        int year=sc.nextInt();

        Calendar d = Calendar.getInstance();

        d.set(year,2,1);

        d.add(Calendar.DATE,-1);
        int date = d.get(Calendar.DATE);

        System.out.println(year+"年2月份有"+date+"天");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mN2bcSUR-1646834555159)(D:\java图\Snipaste_2021-11-12_01-31-26.png)]

异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wf0zg4Qt-1646834555159)(D:\java图\Snipaste_2021-11-12_22-41-02.png)]

ArrayIndexOutOfBoundsException–这个就是数组索引越界异常

JVM在面对异常的默认处理方案

把程序的名称，异常原因及异常出现的位置等信息输出在控制台
程序停止执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjmuYL3N-1646834555159)(D:\java图\Snipaste_2021-11-12_22-50-52.png)]

处理异常–try{}catch(){}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-91F3fTD1-1646834555159)(D:\java图\Snipaste_2021-11-12_22-57-46.png)]

public class Calenda {
    public static void main(String[] args) {
        System.out.println("开始");
    method();
        System.out.println("结束");

    }
    public static void method(){
        try {
            int[] d={1,2,3,4};
            System.out.println(d[4]);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hZYCfVRx-1646834555159)(D:\java图\Snipaste_2021-11-12_23-07-57.png)]

用try—catch后程序可以运行不会中途退出，最好用printStackTrace();方法，提示信息最全

编译时异常和运行时异常的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XhU9rlJv-1646834555160)(D:\java图\Snipaste_2021-11-12_23-34-21.png)]

异常处理之throws

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CK9KX3ni-1646834555160)(D:\java图\Snipaste_2021-11-12_23-43-34.png)]

在编译时出现异常alt+enter选择两种方法中的一种进行处理

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

public class Calenda {
    public static void main(String[] args) throws ParseException {
        method();
        System.out.println("ss");
    }
    public static void method() throws ParseException {
        String s="2002-12-11";
        SimpleDateFormat D=new SimpleDateFormat("yyyy-MM-dd");
        Date a = D.parse(s);
        System.out.println(a);

    }}
//在方法中丢出异常最后还是用调用者处理

自定义异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a57piFTp-1646834555160)(D:\java图\Snipaste_2021-11-12_23-55-22.png)]

自定义异常

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

调用异常

public class Teacher {
    public void checkScore(int score) throws ScoreException {
        //注意throws ScoreException
        if (0<score&&score<100){
            System.out.println("成绩正常");
        }
        else {
          throw new ScoreException("该成绩有误，范围应在0到100分之间");
        }
    }
}//throw用于在方法体内部抛出异常对象

测试

import java.util.Scanner;

public class testq {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入学生成绩：");
        int score = sc.nextInt();

        Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7J6sUgVF-1646834555161)(D:\java图\Snipaste_2021-11-13_00-30-11.png)]

集合体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03QlOTyQ-1646834555161)(D:\java图\Snipaste_2021-11-14_21-24-17.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4mvKEoDz-1646834555161)(D:\java图\Snipaste_2021-11-14_21-30-14.png)]

import java.util.ArrayList;

public class fsf {
    public static void main(String[] args) {
        ArrayList<String> c=new ArrayList<>();
        
        c.add("hello");
        c.add("word");

        System.out.println(c);
    }
}

重写了toString()方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7H9lU70k-1646834555161)(D:\java图\Snipaste_2021-11-14_21-36-13.png)]

Collection集合常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qcqSVIMv-1646834555162)(D:\java图\Snipaste_2021-11-14_21-37-08.png)]

其中remove()在list的实现类创建的集合中，如果集合中要去除的元素有多个则去除第一个

import java.util.ArrayList;

public class fsf {
    public static void main(String[] args) {
        ArrayList<String> c=new ArrayList<>();


        c.add("hello");
        c.add("word");
        c.add("d");
        c.add("word");
        c.add("c");
        c.add("word");

        c.remove("word");
        System.out.println(c);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gedIKA1B-1646834555162)(D:\java图\Snipaste_2021-11-14_21-59-28.png)]

Collection集合的遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hfb9d30A-1646834555162)(D:\java图\Snipaste_2021-11-14_22-40-36.png)]

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

public class fsf {
    public static void main(String[] args) {
        ArrayList<String> c=new ArrayList<>();


        c.add("hello");
        c.add("word");
        c.add("d");
        c.add("word");
        c.add("c");
        c.add("word");


        Iterator<String> ct=c.iterator();

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


        System.out.println(c);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f3xivlU8-1646834555162)(D:\java图\Snipaste_2021-11-14_22-48-46.png)]

Collection集合存储学生类对象

学生类

操作类

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

public class fsf {
    public static void main(String[] args) {
        ArrayList<student> c=new ArrayList<>();
        student s1=new student("包乐培","18");
        student s2=new student("黄婧","19");

        c.add(s1);
        c.add(s2);

        Iterator<student> d=c.iterator();

        while (d.hasNext()){
            student q = d.next();
            System.out.println(q.getName()+","+q.getAge());
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1d1vWZW-1646834555163)(D:\java图\Snipaste_2021-11-14_23-19-34.png)]

在 Iterator迭代器其中无add方法。

list

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwFPZEOF-1646834555163)(D:\java图\Snipaste_2021-11-16_23-33-45.png)]

//创建对象
List<String> d = new ArrayList<>();

ListIterator

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A10cu1E2-1646834555163)(D:\java图\Snipaste_2021-11-17_21-55-24.png)]

ListIterator<String> a= d.listIterator();

        while (a.hasNext()){
            String s = a.next();
            if (s.equals("你")){   //有"你”时"平静"
                a.add("平静");
            }
        }

增强for(最方便的遍历方式只为了遍历)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IS3gycSd-1646834555163)(D:\java图\Snipaste_2021-11-17_22-07-25.png)]

public class list {
    public static void main(String[] args) {

        int[] a={1,12,13,12};
        for (int d:a){
            System.out.println(d);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mRr9Aobf-1646834555163)(D:\java图\Snipaste_2021-11-17_22-11-39.png)]

遍历的3种方式

Iterator迭代器为集合特有的遍历方式(也只为遍历)
for循环带索引
增强for只为遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OOK7jU0O-1646834555167)(D:\java图\Snipaste_2021-11-17_22-32-09.png)]

LinkedList特有功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oROQAmp6-1646834555167)(D:\java图\Snipaste_2021-11-17_22-36-39.png)]

Set集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pa0LR0SP-1646834555167)(D:\java图\Snipaste_2021-11-19_21-26-42.png)]

import java.util.*;

public class list {
    public static void main(String[] args) {
        Set<String> d=new HashSet<>();

        d.add("再见");
        d.add("欺骗");
        d.add("好累");

        //增强for
        for (String s:d){
            System.out.println(s);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xiM3X2Gz-1646834555167)(D:\java图\Snipaste_2021-11-19_21-35-23.png)]

因为不带索引，所以不能用普通的for循环遍历，遍历时也是无序的

哈希值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tJpIuEOE-1646834555167)(D:\java图\Snipaste_2021-11-19_21-44-43.png)]

public class list {
    public static void main(String[] args) {
        System.out.println("再见".hashCode());
        System.out.println("好傻".hashCode());
        System.out.println("----------");
        System.out.println("重地".hashCode());
        System.out.println("通话".hashCode());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MfxULUxO-1646834555167)(D:\java图\Snipaste_2021-11-19_21-50-08.png)]

不同对象的哈希值不一定不想提，但相同对象的哈希值一定相同。如果要使对象不相同的哈希值相同则重写hashCode()方法

学生类(未重写hashCode()方法)

测试类

public class list {
    public static void main(String[] args) {
        Student d1=new Student("大",13);
        Student d2=new Student("防",12);

        System.out.println(d1.hashCode());
        System.out.println(d2.hashCode());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G41Ko7e5-1646834555167)(D:\java图\Snipaste_2021-11-19_22-03-17.png)]

在学生类中重写hashCode()方法

public int hashCode(){
        return 0;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N0tBGNOF-1646834555169)(D:\java图\Snipaste_2021-11-19_22-06-31.png)]

HashSet集合(无索引)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSHJLtdK-1646834555169)(D:\java图\Snipaste_2021-11-19_22-08-58.png)]

构造方法

HashSet<String> d=new HashSet<>();

shift+Tab–将代码往左移

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wbLWKPrI-1646834555169)(D:\java图\Snipaste_2021-11-19_22-15-37.png)]

HashSet集合保证元素唯一性源码分析(面试题)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-16CduCKJ-1646834555169)(D:\java图\Snipaste_2021-11-19_22-47-13.png)]

数据结构之哈希表（用来存储Set集合的内容）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-piwTfnWt-1646834555169)(D:\java图\Snipaste_2021-11-19_23-02-07.png)]

这就是解释为什么要进行位置的查找和判断是否有值

HashSet集合存储学生信息

在学生类中自动重写hashCode()和equals()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YKFTKFQd-1646834555170)(D:\java图\Snipaste_2021-11-19_23-34-02.png)]

LinkedHashSet集合(有序，存储和取出顺序)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5zeKb6k-1646834555170)(D:\java图\Snipaste_2021-11-19_23-39-23.png)]

构造方法

LinkedHashSet<String> b=new LinkedHashSet<>();

TreeSet集合(有序，取决于构造方法)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0cuoajSM-1646834555170)(D:\java图\Snipaste_2021-11-19_23-49-14.png)]

自然排序

import java.util.*;
public class list {
    public static void main(String[] args) {
        TreeSet<Integer> a=new TreeSet<>();//当存储基本类型时要将其转换为对应的包装类型
        a.add(12);//自动装箱
        a.add(14);
        a.add(13);
        a.add(11);
        for (Integer s:a){
            System.out.println(s);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EcQWalbF-1646834555171)(D:\java图\Snipaste_2021-11-19_23-57-12.png)]

自然排序Comparable的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fi0hIVcY-1646834555172)(D:\java图\Snipaste_2021-11-20_21-38-04.png)]

public class Student implements Comparable<Student> {    //实现Comparable接口
    
    @Override
    public int compareTo(Student s) {       //重写compareTo方法
        int b = this.age-s.age;    
        // this.age相当于d2  s.age相当于d1  从小到大排序
        int i = b == 0 ? this.name.compareTo(s.name) :b;
        return i;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JSPIwgey-1646834555172)(D:\java图\Snipaste_2021-11-20_21-54-26.png)]

比较排序 Comparator的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nvnymqxp-1646834555172)(D:\java图\Snipaste_2021-11-21_10-09-25.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jz12iKFL-1646834555172)(D:\java图\Snipaste_2021-11-21_09-59-53.png)]

匿名内部类的方法实现 Comparator接口

 TreeSet<Student> d=new TreeSet<>(new Comparator<Student>(){
            @Override
            public int compare(Student s1, Student s2) {
                int i = s1.getAge() - s2.getAge();
                int i1 = i == 0 ? s1.getName().compareTo(s2.getName()) : i;
                return i1;
            }
        });   //别忘了;   无法直接访问所以用调方法的方式访问

Random随机数

Random b=new Random();
        int i = b.nextInt(20) + 1;  //不加1时是0到19，加上后是1到20

泛型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TVtt0dRE-1646834555173)(D:\java图\Snipaste_2021-11-21_10-31-10.png)]

泛型类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-49PDF7aG-1646834555173)(D:\java图\Snipaste_2021-11-21_10-39-13.png)]

public class Generic<T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

使用

Generic<String> d=new Generic<>();
        d.setT("dad");

泛型方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7gTa10Lm-1646834555173)(D:\java图\Snipaste_2021-11-21_10-57-31.png)]

创建泛型方法

public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
    }

 Generic b=new Generic();
        b.show(13);
        b.show("dsd");
        b.show(12.1);

泛型接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Jw8QYyn-1646834555173)(D:\java图\Snipaste_2021-11-21_11-09-13.png)]

接口

public interface Generic<T> {
    void show(T t);
}

接口实现类

public class GenericImpl <T> implements Generic<T>{   //Impl表示实现接口类
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

类型通配符(作用未知)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xzbPrgXM-1646834555174)(D:\java图\Snipaste_2021-11-21_20-53-57.png)]

8种基本类型的包装类<Number<Object

 List<?> d=new ArrayList<Number>();
        List<?> d1=new ArrayList<Integer>();
        List<?> d2=new ArrayList<Object>();

        List<? extends Number> d3=new ArrayList<Number>();
        List<? extends Number> d4=new ArrayList<Object>();//报错 上限为Number
        List<? extends Number> d5=new ArrayList<Integer>();

可变参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qnZSQbAB-1646834555174)(D:\java图\Snipaste_2021-11-21_21-17-21.png)]

public class list {
    public static void main(String[] args) {
        System.out.println(sum(12,13,13,1,3313));
        System.out.println(sum(12,13,13,1));
        System.out.println(sum(12,13,13));
    }
    public static int sum(int...a){  //这里的a为数组
        int s=0;
        for (int  i:a){    //增强for
            s+=i;
        }
        return s;
    }
    }
//可实现不同个数的参数相加，不用写多个方法求和。

public static int sum(int b,int...a){} //如果有多个参数，包含可变参数，可变参数放最后

将参数包装到一个数组里，通过对数组里元素的运算来实现求和等要求

可变参数的使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNnG43gP-1646834555175)(D:\java图\Snipaste_2021-11-21_21-37-28.png)]

 List<String> a=Arrays.asList("d" , "da" ,"ada" );

List<String> a=List.of("d" , "da" ,"ada" );

Set<String> a=Set.of("d" , "da" ,"ada" );

add(); //增加
remove(); //删除
set(); //修改

Map集合概述和特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tn5GYoZK-1646834555175)(D:\java图\Snipaste_2021-11-22_21-56-38.png)]

import java.util.*;

public class list {
    public static void main(String[] args) {
        Map<String,String> d=new HashMap<String,String>();
        d.put("12","再见");
        d.put("13","谎言");
        d.put("14","痴情");
        d.put("14","好累");
        System.out.println(d);

    }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVu4FPqI-1646834555175)(D:\java图\Snipaste_2021-11-22_22-21-18.png)]

这里存储数据用的是哈希表，这里的Key类似于地址，具有唯一性（但值可重复），从而用put方法时地址重复出现时就是修改数据

基本功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NqhOQWxX-1646834555176)(D:\java图\Snipaste_2021-11-22_22-26-17.png)]

获取功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7uldJlJ0-1646834555176)(D:\java图\Snipaste_2021-11-22_22-51-09.png)]

遍历1

 Set<String> a=d.keySet();  //获取键的集合
        for (String q:a){
            System.out.println(q+","+d.get(q));
        }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tqOD5ssu-1646834555176)(D:\java图\Snipaste_2021-11-22_23-15-06.png)]

遍历2

Set<Map.Entry<String, String>> key = d.entrySet(); 
        for (Map.Entry<String, String> a: key){
            System.out.println(a.getKey()+","+a.getValue());
        }

创建学生集合并遍历

import java.util.*;

public class list {
    public static void main(String[] args) {
        Map<String,Student> student=new HashMap<String,Student>();
        Student d1=new Student("blp",13);
        Student d2=new Student("bdd",12);
        Student d3=new Student("blx",11);

        student.put("112",d1);
        student.put("113",d2);
        student.put("114",d3);

        Set<Map.Entry<String, Student>> entrySet = student.entrySet();
        for (Map.Entry<String, Student> a: entrySet){
            System.out.println
              (a.getKey()+","+a.getValue().getName()+","+a.getValue().getAge());
        }
    }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-saazs1Cz-1646834555176)(D:\java图\Snipaste_2021-11-22_23-38-34.png)]

当键是学生对象时，在学生对象中要重写hashCode()和equals(),自动生成即可

![Snipaste_2021-11-26_22-04-43](D:\java图\Snipaste_2021-11-26_22-04-43.png)import java.util.*;

public class list {
    public static void main(String[] args) {
        Map<Student,String> student=new HashMap<Student,String>();
        Student d1=new Student("blp",13);
        Student d2=new Student("bdd",12);
        Student d3=new Student("blx",11);

        student.put(d1,"112");
        student.put(d2,"113");
        student.put(d3,"114");

        Set<Map.Entry<Student,String>> entrySet = student.entrySet();
        for (Map.Entry<Student,String> a: entrySet){
            System.out.println(a.getValue()+","+a.getKey().getName()+","+a.getKey().getAge());
        }
    }
    }

Collections集合概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oxDInwqj-1646834555176)(D:\java图\Snipaste_2021-11-26_22-04-43.png)]

List<String> list=new ArrayList<>();
        Collections.sort(list);
        Collections.reverse(list);
        Collections.shuffle(list);//父类通过调用方法

Properties

在Hashtable类（效率不及HashMap类，目前基本被取代）有一个子类Properties在实际应用中非常重要。Properties主要用来存储字符串类型的键和值，在实际开发中，经常使用Properties集合类来存取应用的配置项

File类概述及构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U57QQGNN-1646834555178)(D:\java图\Snipaste_2021-11-26_22-31-45.png)]

        File file=new File("d:\\blp\\java");

        File file1=new File("d:\\blp","java");

        File file2=new File("d:\\blp");
        File file3=new File(file2,"java");

File类创建功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-059y4Y4E-1646834555178)(D:\java图\Snipaste_2021-11-26_22-43-27.png)]

        file.createNewFile();//创建文件
        file.mkdir();//创建d:\\blp(当该目录不存在)
        file.mkdirs();//创建d:\\blp\\blx(当该目录不存在)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pXPXVjyf-1646834555178)(D:\java图\Snipaste_2021-11-26_22-53-23.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uni0mpBV-1646834555178)(D:\java图\Snipaste_2021-11-26_23-02-04.png)]

创建的是文件还是目录取决于调用的方法，而非.txt，不能创建同名的文件和目录

File判断和获取功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9OG447Ar-1646834555178)(D:\java图\Snipaste_2021-11-26_23-06-26.png)]

File删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TjLdnLFa-1646834555179)(D:\java图\Snipaste_2021-11-26_23-14-25.png)]

遍历目录

public class list {

    public static void main(String[] args) throws IOException {
        File file = new File("d:\\blp");

        LookFile(file);
    }

    public static void LookFile(File file) {
        File[] array = file.listFiles();
        if (array != null) {
            for (File d : array) {
                if (d.isDirectory()) {
                    LookFile(d);
                } else {
                    System.out.println(d.getAbsolutePath());
                }
            }
        }
    }
}

IO流概述和分类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1K91WKhx-1646834555179)()]

字节流写数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HfUBVg67-1646834555180)(D:\java图\Snipaste_2021-11-28_00-42-38.png)]

FileOutputStream file=new FileOutputStream("AA\\ab");

       file.write(97);
       file.close();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-45srT4Td-1646834555180)(D:\java图\Snipaste_2021-11-28_00-46-40.png)]

字节流写入数据的三种方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i0oa7q7I-1646834555180)(D:\java图\Snipaste_2021-11-28_00-47-30.png)]

FileOutputStream file=new FileOutputStream("AA\\blp.txt");
//        byte[] bytes = "asdfghj".getBytes();//( Byte[] j={};)
//        file.write(bytes);
        byte[] j = "fhakg".getBytes();//将字符转换为对应的字节
        file.write(j,2,2); //写入ak   下标为2长度为2
        file.close();

换行及追加写入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3mNnU4WS-1646834555180)(D:\java图\Snipaste_2021-11-28_23-31-05.png)]

       FileOutputStream file=new FileOutputStream("AA\\blp.txt",true);//追加写入，如果不加则无法追加数据
       file.write("\r\n".getBytes());//换行

用try-catch-finall处理异常

public class list {

    public static void main(String[] args)  {
        
       FileOutputStream file=null;
        try {
            file=new FileOutputStream("AA\\blp.txt");
            file.write("asfdf".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (file!=null)  //判断file是否为空，如果不判断，当file为空时会出现空指针异常
            {
                try {
                    file.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流读数据（一次读一个字节数据）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r4Zz4rB9-1646834555181)(D:\java图\Snipaste_2021-12-02_23-28-17.png)]

       FileInputStream sc=new FileInputStream("zha\\blp.txt");
        int by;
        while ((by=sc.read())!=-1){
            System.out.print((char) by);
        }
        sc.close();

  public FileOutputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null, false);
    }   //File(name)创建

字节流读数据（一次读一个字节数组数据）

public class list {
    public static void main(String[] args) throws IOException {
        FileInputStream file=new FileInputStream("zha\\blp.txt");
        byte[] bytes = new byte[1024];//1024的整数倍
        int len;
        while((len=file.read(bytes))!=-1){
            //将字节数组转换为字符串String(bytes,int 开始转换的下标，int 结束转换的下标)
            System.out.println(new String(bytes,0,len));
        }
        file.close();
    }
}

复制文本文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4zWrLc47-1646834555181)(D:\java图\Snipaste_2021-12-02_23-56-18.png)]

        FileInputStream sc=new FileInputStream("zha\\blp.txt");
        FileOutputStream s=new FileOutputStream("d:\\bl\\blp.txt");

        int by;
        while ((by=sc.read())!=-1){
            s.write((char)by);
        }
        sc.close();

读数据，写数据

字节流复制图片

public class list {

    public static void main(String[] args) throws IOException {
        FileInputStream file=new            FileInputStream("C:\\Users\\99456\\Pictures\\0XLuyVk6J_2tQ5.jpg");
        FileOutputStream files=new FileOutputStream("zha\\0XLuyVk6J_2tQ5.jpg");
        int read ;
            while ((read=file.read())!=-1){
                files.write(read);
            }
            file.close();
            files.close();
    }
}

字节缓冲流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JY7gEaEt-1646834555181)(D:\java图\Snipaste_2021-12-05_16-11-27.png)]

缓冲区

10个人搬10包水泥到3公里远的施工区，总路程30公里。但现在1.5公里处有辆卡车，现在可以让这10个人先把水泥搬上卡车，再让卡车运到施工地，放水泥的只可以一人放或一辆车放。速度相同的情况下，卡车效率更高

字节流本身不带缓冲区，字符流自带缓冲区。在缓冲字节流中如果一次读取数据量较小(远小于缓冲区的容量大小)则效率提升大，但如果一次读取的数据远大于缓冲区容量(本来调用一次就可以但用了缓冲区后反而调用多次)导致效率并没有提高

缓冲区也有大小

 BufferedInputStream b=new BufferedInputStream(new FileInputStream("d:\\blp"));
        int bb;
        while ((bb=b.read())!=-1){
            System.out.println((char)bb);
        }
        b.close();

BufferedOutputStream bc=new BufferedOutputStream(new FileOutputStream("d:\\blp"));
        bc.write("dsgfhg".getBytes());
        bc.close();

为什么出现字符流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QVt0jQcg-1646834555182)(D:\java图\Snipaste_2021-12-06_20-06-21.png)]

编码表

中文在UTF-8中占3字节，在GBK中占2个字节

字符串中的编码解码问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L4OCc5b2-1646834555182)(D:\java图\Snipaste_2021-12-06_20-09-07.png)]

public class list {
    public static void main(String[] args) throws IOException {
      String s="岸边";
      byte[] ss = s.getBytes();
        String sss=new String(ss);
        System.out.println(sss);
    }
}

字符流中的编码解码问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q14gglHB-1646834555183)(D:\java图\Snipaste_2021-12-09_19-01-31.png)]

写入

public class list {
    public static void main(String[] args) throws IOException {
     OutputStreamWriter fis=new OutputStreamWriter(new FileOutputStream("zha//blp.txt"));
     fis.write("尴尬吗");
     fis.close();
    }
}

读取

public class list {
    public static void main(String[] args) throws IOException {
        InputStreamReader fis = new InputStreamReader(new FileInputStream("zha//blp.txt"));
        int len;
        while ((len = fis.read()) != -1) {
            System.out.print((char) len);
        }
        fis.close();
    }
}

字符流写入数据的5种方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rpAfhVA0-1646834555183)(D:\java图\Snipaste_2021-12-09_19-20-55.png)]

与字节流相比，字符流可以直接写入字符串，而字节流要将字符串转化为字节数组

字符流

public class list {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter fis=new OutputStreamWriter(new FileOutputStream("zha//blp.txt"));
        fis.write("尴尬，但尴尬的那个人不会是我");
        fis.close();
    }
}

字节流

public class list {
    public static void main(String[] args) throws IOException {
       FileOutputStream fis=new FileOutputStream("zha//blp.txt");
       fis.write("尴尬，但尴尬的那个人不会是我".getBytes());
       fis.close();
    }
}

字符流两种读取数据的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3hSQJeLv-1646834555183)(D:\java图\Snipaste_2021-12-09_19-39-24.png)]

一次读一个字符数组数据

public class list {
    public static void main(String[] args) throws IOException {
       InputStreamReader fis=new InputStreamReader(new FileInputStream("zha//blp.txt") );
       char[] chars=new char[1024];
       int len;
       while ((len=fis.read(chars))!=-1){
           System.out.print(new String(chars,0,len));
       }
       fis.close();
    }
}

字符流复制java文件

public class list {
    public static void main(String[] args) throws IOException {
       InputStreamReader fis=new InputStreamReader(new FileInputStream("D:\\java代码\\zha\\src\\wu\\Student.java") );
       OutputStreamWriter fos=new OutputStreamWriter(new FileOutputStream("g//src//d//Student.java"));
       char[] chars=new char[1024];
       int len;
       while ((len=fis.read(chars))!=-1){
           fos.write(new String(chars,0,len));
       }
       fis.close();
       fos.close();
    }
}

读/写入字符文件的便捷类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bQIpHgif-1646834555183)(D:\java图\Snipaste_2021-12-09_20-12-26.png)]

public class list {
    public static void main(String[] args) throws IOException {
       FileReader fis=new FileReader("D:\\java代码\\zha\\src\\wu\\Student.java");
        FileWriter fos=new FileWriter("g\\src\\d\\Student.java");
        char[] chars=new char[1024];
       int len;
       while ((len=fis.read(chars))!=-1){
           fos.write(new String(chars,0,len));
       }
       fis.close();
       fos.close();
    }
}

字符缓冲流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iyWB6lzU-1646834555184)(D:\java图\Snipaste_2021-12-09_20-30-17.png)]

构造方法

BufferedWriter buw=new BufferedWriter(new FileWriter("g\\src\\d\\Student.java"));
      BufferedReader bur=new BufferedReader(new FileReader("D:\\java代码\\zha\\src\\wu\\Student.java"));

特有功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mo1GFdZ0-1646834555184)(D:\java图\Snipaste_2021-12-09_20-36-46.png)]

public class list {
    public static void main(String[] args) throws IOException {
        BufferedWriter buw = new BufferedWriter(new FileWriter("zha//blp.txt"));
        for (int i = 0; i < 5; i++) {
            buw.write("忘记");
            buw.newLine();//换行，避免不兼容问题(/r/n,/n,/r)
        }
        buw.close();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CNuoR609-1646834555184)(D:\java图\Snipaste_2021-12-09_20-42-47.png)]

//结果和上图一样
public class list {
    public static void main(String[] args) throws IOException {
        BufferedReader bur=new BufferedReader(new FileReader("zha//blp.txt"));
        String s ;
        while ((s=bur.readLine())!=null) {
            System.out.println(s);//一次读取以后，不读取换行符，所以用println
        }
        bur.close();
    }
}

用字符缓存流复制java文件

public class list {
    public static void main(String[] args) throws IOException {
        BufferedReader bur=new BufferedReader(new FileReader("score\\src\\test\\fsf.java"));
        BufferedWriter buw=new BufferedWriter(new FileWriter("zha\\src\\wu\\fsf.java"));
        String s;
        while ((s=bur.readLine())!=null){
            buw.write(s);
            buw.newLine();
            buw.fluch();
        }
        bur.close();
        buw.close();
    }
}

I/O流小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zHodlwFN-1646834555185)(D:\java图\Snipaste_2021-12-11_18-23-14.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0MJQlOAt-1646834555185)(D:\java图\Snipaste_2021-12-11_18-26-03.png)]

所以复制图片，视频等应用字节流

集合到文件

public class list {
    public static void main(String[] args) throws IOException {
       ArrayList<String> s=new ArrayList<>();
       s.add("上帝");
       s.add("是");
       s.add("女孩");

       BufferedWriter buw=new BufferedWriter(new FileWriter("zha\\src\\wu\\nhai.txt"));

       for(String ss:s){
           buw.write(ss);
           buw.newLine();
           buw.flush();
       }
       buw.close();
    }
}

这个是缓冲区的问题.
java在使用流时,都会有一个缓冲区,按一种它认为比较高效的方法来发数据:把要发的数据先放到缓冲区,缓冲区放满以后再一次性发过去,而不是分开一次一次地发.
而flush()表示强制将缓冲区中的数据发送出去,不必等到缓冲区满.所以如果在用流的时候,没有用flush()这个方法,很多情况下会出现流的另一边读不到数据的问题,特别是在数据特别小的情况下。java.io.OutputStream.flush() 方法刷新此输出流并强制将所有缓冲的输出字节被写出。

也就是说当使用缓冲流写入数据时，在write方法后都应当加上fluch方法

文件到集合

public class list {
    public static void main(String[] args) throws IOException {
        ArrayList<String> s = new ArrayList<>();

        BufferedReader bur = new BufferedReader(new FileReader("zha\\src\\wu\\nhai.txt"));
        String line;
        while ((line = bur.readLine()) != null) {
            s.add(line);
        }
        for (String ss : s) {
            System.out.println(ss);
        }
        bur.close();
    }
}

利用StringBuilder进行字符串的拼接

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class list {
    public static void main(String[] args) throws IOException {
        ArrayList<Student> arrayList=new ArrayList<>();
        Student s=new Student("20020927","blp","19","江西");
        StringBuilder ss=new StringBuilder();
        ss.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
        System.out.println(ss);
    }
}

ss.append()返回的是对象

文件到集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zYGsjkij-1646834555185)(D:\java图\Snipaste_2021-12-11_20-08-52.png)]

注意split()和Integer.parsrInt()

集合到文件

public class adsf {
    public static void main(String[] args) throws IOException {
        BufferedWriter buw=new BufferedWriter(new FileWriter("zha\\bb.txt",true));
        Student student=new Student("blp",123,12,133);
        StringBuilder ss=new StringBuilder();
        ss.append(student.getName()).append(",").append(student.getMath()).append(",").append(student.getEnglish()).append(",").append(student.getChinese());
        String s = ss.toString();
        buw.write(s);
        buw.close();
    }
}

字符打印流

public class adsf {
    public static void main(String[] args) throws IOException {
        PrintWriter pw=new PrintWriter(new FileWriter("zha\\bb.txt",true),true);
        //第一个turn是追加写入，第二个是刷新
        pw.println("第sdf");
        pw.close();
    }
}

反射及注解

动态语言

是一类在运行时可以改变其结构的语言:
例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。

通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言:Object-C、C#、JavaScript、PHP、Python等。

静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。

如Java、C、C++。
Java不是动态语言，但Java可以称之为
“准动态语言”。即Java有一定的动态性,
我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection APl取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c= Class.forName(“java.lang.String”)

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G0zt3yTi-1646834555186)(D:\java图\QQ图片20220221130111.png)]

网络编程

1.2、网络通信的要素

如何实现网络的通信?

通信双方地址:

ip
端口号
192.168.16,124:5900规则:网络通信的协议

小结:
1.网络编程中有两个主要的问题

如何准确的定位到网络上的一台或者多台主机。

找到主机之后如何进行通信

2.网络编程中的要素

IP和端口号lP

网络通信协议

3.万物皆对象

ip地址: InetAddress

唯一定位一台网络上计算机·

127.0.0.1:本机 localhost

·ip地址的分类
ipv4 / ipv6
iPV4 127.0.0.1，4个字节组成。，0_255，42亿 ; 30亿都在美，亚洲4亿。2011年就用尽;

iPV6:128位。8个无符号整数!

eg：2001: 0bb2: aaaa: 0015:0000:0000 : 1aaa:1312

公网(互联网)-私网(局域网)

ABCD类地址
192.168.x×.xx,专门给组织内部使用的
·域名:记忆IP问题!
IP: www.vip.com

端口表示计算机上的一个程序的进程;
·不同的进程有不同的端口号!用来区分软件!·

被规定0~65535

.TCP，UDP : 65535* 2 tcp: 80，udp:80 单个协议下，端口号不能冲突·

端口分类

。公有端口0~1023

HTTP: 80

HTTPS: 443

FTP∶21

Telent : 23
。程序注册端口:1024~49151,分配用户或者程序
Tomcat : 8080

MysQL : 3306.
Oracle : 1521
动态、私有:49152~65535

TCP udp对比

TCP:打电话

连接，稳定

三次握手四次挥手

1最少需要三次，保证稳定连接!

2A:你瞅啥?
3B:瞅你咋地?
4A:干一场!

7A:我要走了!
8B:你真的要走了吗?
9B:你真的真的要走了吗?
10A:我的真的要走了!

传输完成，释放连接，
效率低

UDP:发短信

不连接，不稳定
客户端、服务端:没有明确的界限
不管有没有准备好，都可以发给你…
导弹
DDOS:洪水攻击!(饱和攻击)

URL

https://www.baidu.com/
统一资源定位符:定位资源的，定位互联网上的某一个资源DNS域名解析www.baidu.com xXX.X…X…×

1协议://ip地址:端口/项目名/资源

package url;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class urlDemon01 {
    public static void main(String[] args) throws Exception {
        //下载地址
        URL url = new URL("http://localhost:8080/blp/Snipaste_2021-11-05_21-26-08.png");
        //连接
        HttpURLConnection oo = (HttpURLConnection) url.openConnection();
        //读取数据流
        InputStream inputStream = oo.getInputStream();
        //创建文件输出流,复制后的文件路径
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\bxb.png");
        //写出数据
        byte[] bytes = new byte[1024];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }

        fileOutputStream.close();
        inputStream.close();
        oo.disconnect();
    }
}

反射及注解

动态语言

是一类在运行时可以改变其结构的语言:
例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。

通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言:Object-C、C#、JavaScript、PHP、Python等。

静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。

如Java、C、C++。
Java不是动态语言，但Java可以称之为
“准动态语言”。即Java有一定的动态性,
我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

Class c= Class.forName(“java.lang.String”)

[外链图片转存中…(img-G0zt3yTi-1646834555186)]

网络编程

1.2、网络通信的要素

如何实现网络的通信?

通信双方地址:

ip
端口号
192.168.16,124:5900规则:网络通信的协议

小结:
1.网络编程中有两个主要的问题

如何准确的定位到网络上的一台或者多台主机。

找到主机之后如何进行通信

2.网络编程中的要素

IP和端口号lP

网络通信协议

3.万物皆对象

ip地址: InetAddress

唯一定位一台网络上计算机·

127.0.0.1:本机 localhost

·ip地址的分类
ipv4 / ipv6
iPV4 127.0.0.1，4个字节组成。，0_255，42亿 ; 30亿都在美，亚洲4亿。2011年就用尽;

iPV6:128位。8个无符号整数!

eg：2001: 0bb2: aaaa: 0015:0000:0000 : 1aaa:1312

公网(互联网)-私网(局域网)

ABCD类地址
192.168.x×.xx,专门给组织内部使用的
·域名:记忆IP问题!
IP: www.vip.com

端口表示计算机上的一个程序的进程;
·不同的进程有不同的端口号!用来区分软件!·

被规定0~65535

.TCP，UDP : 65535* 2 tcp: 80，udp:80 单个协议下，端口号不能冲突·

端口分类

。公有端口0~1023

HTTP: 80

HTTPS: 443

FTP∶21

Telent : 23
。程序注册端口:1024~49151,分配用户或者程序
Tomcat : 8080

MysQL : 3306.
Oracle : 1521
动态、私有:49152~65535

TCP udp对比

TCP:打电话

连接，稳定

三次握手四次挥手

1最少需要三次，保证稳定连接!

2A:你瞅啥?
3B:瞅你咋地?
4A:干一场!

7A:我要走了!
8B:你真的要走了吗?
9B:你真的真的要走了吗?
10A:我的真的要走了!

传输完成，释放连接，
效率低

UDP:发短信

不连接，不稳定
客户端、服务端:没有明确的界限
不管有没有准备好，都可以发给你…
导弹
DDOS:洪水攻击!(饱和攻击)

URL

https://www.baidu.com/
统一资源定位符:定位资源的，定位互联网上的某一个资源DNS域名解析www.baidu.com xXX.X…X…×

1协议://ip地址:端口/项目名/资源

package url;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class urlDemon01 {
    public static void main(String[] args) throws Exception {
        //下载地址
        URL url = new URL("http://localhost:8080/blp/Snipaste_2021-11-05_21-26-08.png");
        //连接
        HttpURLConnection oo = (HttpURLConnection) url.openConnection();
        //读取数据流
        InputStream inputStream = oo.getInputStream();
        //创建文件输出流,复制后的文件路径
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\bxb.png");
        //写出数据
        byte[] bytes = new byte[1024];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }

        fileOutputStream.close();
        inputStream.close();
        oo.disconnect();
    }
}