//第一种方式
String str=new String("你好");
//第二种方式
String str="你好";
//其他方式
String str="你"+"好";

//因为直接用==比较的是对象地址，所以比较时可能字符串相同但是内存地址不同而出错，所以要使用equals
String str1="你好";
String str2="你不好";
System.out.println(str1.equals(str2));

//把英文忽略大小写比较
String str1="HELLO";
String str2="hello";
System.out.println(str1.equalsIgnoreCase(str2));  //把str1和str2忽略大小写比较

false
true

//传入参数：下标（索引），从0开始
//单个字符串
String str1="你好,你今天吃饭了吗";
System.out.println(str1.charAt(5));   //获取str1下标为5的字

//多个字符串
//截取str1中从下标为5的字符开始到末尾，因为String不可变，所以用str4接收截取后的字符串
String str2=str1.substring(5); 
//截取str1中从下标为5的字符开始到下标为7的字符串（不包括下标为7的字符串）
String str3=str1.substring(5,7);
System.out.println(str2);
System.out.println(str3);

天    //返回str1字符串的第六个字
    
天吃饭了吗  //从第六个字到末尾
天吃      //从第六个字到第7个字

//不需要传参
String str1="你好,你今天吃饭了吗";
System.out.println(str1.length());   //返回str1字符串的长度（汉字个数）

10

//传入参数：要查找的字符串（数字……）
String str1="HELLO WORD";
String str2="WORD";
System.out.println(str1.indexOf(str2));   //在str1中查找str2得位置

6    //反回str1中str2第一个字（W）的下标,没有找到返回-1

//传入参数： str1 原字符串   str2要替换的字符串
//把str1中的空格替换为-
String str1="HELLO WORD";
String str2=" ";
String str3="-";
//对str1进行替换 把str1中的str2替换成str3，因为String不可变，所以用str4接收改变后的字符串
String str4=str1.replace(str2,str3); 
System.out.println(str4);

HELLO-WORD 

//  串入参数：str2 ，str3 要比较的字符串
String str1="HELLO WORD";
String str2="HEL";
String str3="RD";
System.out.println(str1.startsWith(str2));  //比较str1是否以str2开头
System.out.println(str1.endsWith(str3));    //比较str1是否以str3结尾

//大写转小写 传入参数：不可修改 Locale.ROOT （系统语言设置）
String str1="HELLO WORD";
String str3=str1.toLowerCase(Locale.ROOT);  //把str1转化为小写的结果存在str3里
System.out.println(str3);

//小写转大写
String str2="hello word";
String str4=str2.toUpperCase(Locale.ROOT);  //把str1转化为小写的结果存在str4里
System.out.println(str4);

hello word
HELLO WORD

//无须传参
String str1="     你好     ";
String str2=str1.trim();   //去除str1里的空格,因为String不可变，所以用str2接收改变后的字符串
System.out.println(str2);

你好   //结果无空格

//创建StringBuilder对象时将String对象传入转化为StringBuilder对象
StringBuilder str01=new StringBuilder("你好");
//StringBuilder对象可直接打印
System.out.println(str01);   

你好

//StringBuilder对象.setCharAt(字符串下标，要改成的值)
StringBuilder str02=new StringBuilder("你好");
 str02.setCharAt(0, '他');  //替换的值必须是char类型
System.out.println(str02);

他好

//StringBuilder对象.append(要增加的字符串)
StringBuilder str02=new StringBuilder("他好");
str02.append("的很");   //传入字符串或其他类型
 System.out.println(str02);

他好的很

// 无需传参 StringBuilder对象.reverse()
StringBuilder str02=new StringBuilder("他好");
str02.reverse();  //倒转 str02
System.out.println(str02);

好他

//  StringBuilder对象.(插入位置下标，插入字符串)
StringBuilder str02=new StringBuilder("没钱");
str02.insert(1,"有");    //向没和钱中间加入有
System.out.println(str02);

//链式调用
StringBuilder str03=new StringBuilder("没钱");
str03.insert(1,"有").insert(2,"1").insert(2,"3");  //对str03连续使用insert插入字符
System.out.println(str03);

没有钱
没有31钱

// StringBuilder对象.delete(开始下标，结束下标)
StringBuilder str02=new StringBuilder("没钱");
str02.delete(1,2);    //删除str02下标1到下标2的字符串（不包括下标2）
System.out.println(str02);

没

//创建StringBuffer对象时将String对象传入转化为StringBuffer对象
StringBuffer str01=new StringBuffer("你好");
//StringBuffer对象可直接打印
System.out.println(str01);

你好

//StringBuffer对象.setCharAt(字符串下标，要改成的值)
StringBuffer str01=new StringBuffer("你好");
 //替换的值必须是char类型 
str01.setCharAt(0, '我'); //把你替换成我
System.out.println(str01);

我好

//StringBuffer对象.append(要增加的字符串)
StringBuffer str01=new StringBuffer("你好");
str01.append("吗");    //传入字符串或其他类型
System.out.println(str01);

你好吗

// 无需传参 StringBuffer对象.reverse()
StringBuffer str01=new StringBuffer("你好");
str01.reverse();  //把str01倒转
System.out.println(str01);

好你

//  StringBuffer对象.(插入位置下标，插入字符串)
StringBuffer str01=new StringBuffer("没朋友");
str01.insert(1,"女");  //在没和朋中间插入女
System.out.println(str01);

//链式调用
StringBuffer str04=new StringBuffer("没朋友");
str04.insert(1,"女").insert(1,"啥");  //对str04连续调用insert方法插入值
System.out.println(str04);

没女朋友
没啥女朋友

//StringBuffer对象.delete(开始下标，结束下标)
StringBuffer str01=new StringBuffer("没朋友");
str01.delete(1,2);     //删除str02下标1到下标2的字符串（不包括下标2）
System.out.println(str01);

没友

//传参  浮点数
System.out.println(Math.ceil(3.2));    //把3.2向上取整

4.0

//传参 浮点数
System.out.println(Math.floor(3.26));  //把3.26向下取整

3

//传参 浮点数
System.out.println(Math.round(3.6));  //把3.6进行四舍五入的运算
System.out.println(Math.round(3.2));  //把3.6进行四舍五入的运算

4
3

//传参：任意数字类型参数
System.out.println(Math.abs(-5));  //对-5取绝对值

5

//传参：要开平方的数
System.out.println(Math.sqrt(9));   //对9开平方

3.0

// 要进行幂运算的数，进行多少次方运算
System.out.println(Math.pow(4,3));   //运算4的3次方

64.0

System.out.println(Math.PI); //  π
System.out.println(Math.E);  //e

3.141592653589793
2.718281828459045

//无需传参 
System.out.println(Math.random());    //获得0-1之间的随机浮点数（结果包括0不包括1）

0.5604021802601352

//实例   enum 枚举类名{枚举1，枚举2，枚举3…… }
enum week{MON,TUE,WED,THUR,FRI,SAT,SUN}

try {
可能出现异常的代码
}catch (可能发生的异常类型a  异常对象){   
        发生异常a的处理方法    
}catch (可能发生的异常类型b 异常对象){
        发生异常b的处理方法   
}finally {
    无论是否异常都会在最后执行        
}

class Cat{
    public int age=10;
    public String name="宝马";
    int price=500000;

    public int getPrice() {
        return price;
    }
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

//1 通过Class.forName()方法得到class对象
Class<?> cls=Class.forName("Test01.Cat");
System.out.println(cls);
//2 通过 类名.class 得到class对象
Class<Cat> cat01 = Cat.class;
System.out.println(cat01);
//3 通过 对象.getClass()方法得到class对象
Cat cat02 = new Cat();
Class cat03=cat02.getClass();
System.out.println(cat03);
//4通过类加载器得到class对象
//4.1先得到类加载器
Cat cat04 = new Cat();
ClassLoader loader=cat04.getClass().getClassLoader();
//4.2使用加载器的loadClass方法得到class对象
Class cls=loader.loadClass("java.lang.String");
System.out.println(cls);
//包装数据类型可以通过.TYPE获得基本数据类型的class对象
Class<Integer> type = Integer.TYPE; //此方法得得到的Class对象与int.class得到的class对象相同
System.out.println(type); 

class Test01.Cat
class Test01.Cat
class Test01.Cat
class java.lang.String
    int

class Cat{
    public int age=10;
    public String name="宝马";
    int price=500000;

    public int getPrice() {
        return price;
    }
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

//使用Class.forName方法传入String类的全类名得到String类的class对象，Class<?>尖括号中的问号代表任意类型，尖括号可以去掉（此示例使用String类做演示在实际使用时可改为其他类）
//得到class对象
Class<?> cls=Class.forName("Test01.Cat"); //得到String类的class对象
//输出cls
/*1*/System.out.println(cls); //输出cls是哪一个类的class对象
/*2*/System.out.println(cls.getClass()); //输出class是个什么类的对象（运行类型）
//获得包名
/*3*/System.out.println(cls.getPackage().getName());
//得到全类名
/*4*/System.out.println(cls.getName());
//创建类对象
Cat cat01= (Cat) cls.newInstance();//如果不进行强制转化通过newInstance方法创建的对象默认是Object对象，实际运行类型还是Cat对象
//jdk1.9以后的版本建议使用Cat cat01=(Cat) cls.getDeclaredConstructor().newInstance();获得Cat实例
/*5*/System.out.println(cat01);
//通过反射获取对象属性
Field age= cls.getField("age"); //获取class对象中的age属性，如果属性是私有的会报错
/*6*/System.out.println(age.get(cat01)); //使用 属性.get(对象)方法得到cat01对象中的age属性并输出
//通过反射修改对象的值
age.set(cat01,15);
/*7*/System.out.println(age.get(cat01));
//获得所有的对象属性
Field[] fie01 = cls.getFields();
/*8*/System.out.println(Arrays.toString(fie01));

class Test01.Cat
class java.lang.Class
Test01
Test01.Cat
Cat{age=10, name='宝马', price=500000}
10
15
[public int Test01.Cat.age, public java.lang.String Test01.Cat.name]

class  Cat{
    public int age=10;
    public String name="宝马";
    int price=500000;
    private int hight=2;

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

    Cat(int age, String name, int price) {
        this.age = age;
        this.name = name;
        this.price = price;
    }

    public int getPrice() {
        return price;
    }
    public String getCollection(int price){if(price>300000){return "高级";}else{return "普通";}}
    private int getNewPrice(int price,int age){return price/age;}
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

//此处使用getField的方法得到Field对象
Class<?> cls=Class.forName("Test01.Cat"); //创建一个Cat类的class对象
Field fie=cls.getField("age"); //通过class对象创建一个age属性的Field对象，此方法只能获取public修饰的属性的Field对象

Class<?> cls= Class.forName("Test01.Cat");//创建一个Cat类的class对象
Field fie=cls.getField("age");//通过class对象创建一个age属性的Field对象
System.out.println(fie.getModifiers()); //输出age属性修饰符的值

Class<?> cls= Class.forName("Test01.Cat");//创建一个Cat类的class对象
Field fie=cls.getField("age");//通过class对象创建一个age属性的Field对象
Class cls01=fie.getType();//age是int类型的，所以cls01是int的class对象
System.out.println(cls01); //输出class对象

Class<?> cls= Class.forName("Test01.Cat");//创建一个Cat类的class对象
Field fie=cls.getField("age");//获取属性age的Field对象
System.out.println(fie.getName());//输出Field对象对应属性名

age

Class<?> cls= Class.forName("Test01.Cat");//创建一个Cat类的class对象
Field field01= cls.getDeclaredField( "age"); //获取属性age的Field对象
Object o = cls.newInstance(); //创建Cat对象
System.out.println(field01.get(o)); //通过Field对象使用get方法传入 Field对象对应的属性 所在的类对象获取Field对象对应的属性值（此处field01对象对应的属性是age，age所在的类是Cat所以传入cat对象即可）

Class<?> cls= Class.forName("Test01.Cat"); //创建一个Cat类的class对象
//得到Field对象
Field field01= cls.getField( "age");//获取属性age的Field对象
Object o = cls.newInstance();//创建一个Cat对象
//修改对象的值
field01.set(o,20);//对Field对象使用set方法，第一个传入要修改的对象第二个传入想要修改成的值（例如此处是想要把o对象的age值改为20），如果Field对象对应的属性修饰符为static
System.out.println(o);//输出修改后的对象

Class<?> cls= Class.forName("Test01.Cat");//创建一个Cat类的class对象
//得到Field对象
Field field01= cls.getDeclaredField( "hight");//使用getDeclaredField方法获取Field对象（hight属性由private修饰，使用getField方法不能获得Field对象）
Object o = cls.newInstance();//创建一个Cat对象
//修改对象的值
field01.setAccessible(true);//使用爆破，作用是使Field对象的set方法能够成功修改传入对象的值（如果不进行爆破，直接使用set方法修改对象的值会因为访问权限的问题报错）
field01.set(o,5);//第一个传入修改的对象第二个传入修改的值
System.out.println(field01.get(o));//输出对象o的age值

Class<?> cls= Class.forName("Test01.Cat");   //创建class对象
Method field02= cls.getMethod("getCollection", int.class);//使用getMethod方法获得public修饰的方法的Method对象，第一个实参是方法名，后面的实参是调用getNewPrice方法需要传入形参类型的class对象（如果原方法无需传参则只传入方法名即可）
Method field01= cls.getDeclaredMethod("getNewPrice", int.class, int.class); //使用getDeclaredMethod方法获得public和非public修饰的方法的Method对象，第一个实参是方法名，后面的实参是调用getNewPrice方法需要传入形参类型的class对象（如果原方法无需传参则只传入方法名即可）
System.out.println(field02);
System.out.println(field01);

public java.lang.String Test01.Cat.getCollection(int)
private int Test01.Cat.getNewPrice(int,int)

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
Method met=cls.getMethod("toString"); //创建toString方法的Method对象
System.out.println(met.getModifiers());//获取修饰符的值

1

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
Method met=cls.getMethod("toString");//创建toString方法的Method对象
Class cls2=met.getReturnType(); //得到返回值对应类型的class对象
System.out.println(cls2); //输出class对象

class java.lang.String //因为返回值是String类型的所以这里打印了String类型的class对象

Class<?> cls= Class.forName("Test01.Cat");//创建class对象
Method met=cls.getMethod("toString");//创建toString方法的Method对象
String cls2=met.getName(); //得到方法名
System.out.println(cls2); //打印方法名

toString

Class<?> cls= Class.forName("Test01.Cat");//创建class对象
Method met=cls.getMethod("toString");//创建toString方法的Method对象
Class<?>[] cls2=met.getParameterTypes(); //获取toString方法所有形参的class对象的数组
System.out.println(Arrays.toString(cls2));//打印数组

[]

Class<?> cls= Class.forName("Test01.Cat");//创建class对象
Method field02= cls.getMethod("getCollection", int.class); //通过class对象创建getCollection方法的Method对象
Object o = cls.newInstance(); //创建一个Cat对象
System.out.println(field02.invoke(o,400000));//对Method对象使用invoke方法调用Method对象关联的方法，传入的第一个值为Method对象关联的方法所在的类的对象（此处getCollection方法所在的了类为Cat类），后面的值为调用Method对象关联的方法所需要的实参

高级

Class<?> cls= Class.forName("Test01.Cat");//创建class对象
Method field01= cls.getDeclaredMethod("getNewPrice", int.class, int.class);//通过class对象创建getCollection方法的Method对象
Object o = cls.newInstance();//创建一个Cat对象
field01.setAccessible(true); //进行爆破，作用是使Method对象可以正常使用invoke方法调用与Method对象关联的被非public修饰符修饰的方法
System.out.println(field01.invoke(o,400000,10));//调用方法输出返回值（当Method对象关联的是静态方法时，穿入的对象（即此处的o）可以为null）

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
Constructor<?> met=cls.getDeclaredConstructor();//获取Cat类默认的无参构造方法对象（即Constructor对象），本次演示的无参构造器不带public(默认无参构造方法也不带public)，所以要用getDeclaredConstructor方法，否则会报错
String cls2=met.getName(); //获取方法名
System.out.println(cls2); //打印方法名

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
//得到构造器
Constructor<?> met=cls.getConstructor(int.class,String.class); //向getConstructor方法传入有参构造器形参类型的class对象即可得到该类的有参构造器，例如此处的构造器是 public Cat(int age, String name){……}形参是age和name他们的类型分别是int和String，向getConstructor方法传入int和String的class对象即可获得此构造器
//创建对象
Object cat01=met.newInstance(15,"五凌鸿光"); //通过newInstance方法传入public有参构造器需要的参数获得对象，cat01的运行类型是Cat
System.out.println(cat01);

Cat{age=15, name='五凌鸿光', price=500000}

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
//得到构造器
Constructor<?> met=cls.getDeclaredConstructor(int.class,String.class,int.class);//获取有参构造器，因为此构造方法是非public的所以要使用getDeclaredConstructor（传参规则与getConstructor相同）
//创建对象
met.setAccessible(true);//爆破，作用是使newInstance方法能够调用非public构造方法创建对象（如果不进行爆破，newInstance方法会因为不能调用非public的构造方法创建对象而报错）
Object cat01=met.newInstance(12,"大众",400000); //传入有参构造器需要的参数类型创建对象，cat01的运行类型是Cat
System.out.println(cat01);

Cat{age=15, name='五凌鸿光', price=400000}

Class<?> cls= Class.forName("Test01.Cat"); //创建class对象
Constructor<?> met=cls.getDeclaredConstructor();  //创建Constructor对象
int cls2=met.getModifiers(); //获取无参构造方法的修饰符的值
System.out.println(cls2); //输出值

0

Class<?> cls= Class.forName("Test01.Cat");//创建class对象
Constructor<?> met=cls.getDeclaredConstructor();//创建Constructor对象
Class<?>[] cls2 = met.getParameterTypes();//获取默认构造方法所有形参的class对象的数组
System.out.println(Arrays.toString(cls2));//打印class数组

[]

// 不传参时默认表示现在时间
Date time01=new Date();      //创建现在的时间对象
System.out.println(time01);  //输出时间对象time01

//传入数字x表示 1970年一月一日0点后的第x毫秒的时间点

Date time02=new Date(10000);   //1970年一月一日8加上10000毫秒
System.out.println(time02);    //输出时间对象time02

Sat Mar 26 16:12:33 CST 2022
Thu Jan 01 08:00:10 CST 1970    //因为电脑所设的时区是东8区 所以起始时间为8点

// 无需传参 Date对象.getTime()
Date time01=new Date();  //创建现在的时间对象
//获取1970.1.1 00：00：00到time01的时间
long lomg01=time01.getTime(); 
System.out.println(lomg01);

1648284349568  //单位毫秒

//   时间对象1.after(时间对象2)


//比较时间对象1是否在时间对象2后
Date time01=new Date(1000);  //1970.1.1 00：00：01
Date time02=new Date();  //现在时间
boolean lo02=time01.after(time02); //比较time01是否在time02后
System.out.println(lo02);

//比较时间对象1是否在时间对象2前
Date time01=new Date(1000);   //1970.1.1 00：00：01
Date time02=new Date();   //现在时间
boolean lo02=time01.before(time02);  //比较time01是否在time02前
System.out.println(lo02);

//比较时间对象1是否和间对象2相等
Date time01=new Date(1000);   //1970.1.1 00：00：01
Date time02=new Date();    //现在时间
boolean lo02=time01.equals(time02);  //比较time01是否和time02相等
System.out.println(lo02);

false
true
false

//无需传参
Date time02=new Date(); // 创建Date对象
Instant time03=time02.toInstant();  //转化为Instant类对象

import java.util.Calendar;
import java.util.GregorianCalendar;

//传入参数：年，月，日，时，分，秒  不传参默认设置为现在时间
Calendar time01=new GregorianCalendar(2022,5,26,20,23,0); //设置时间
System.out.println(time01);

java.util.GregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=false,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=?,YEAR=2022,MONTH=5,WEEK_OF_YEAR=?,WEEK_OF_MONTH=?,DAY_OF_MONTH=26,DAY_OF_YEAR=?,DAY_OF_WEEK=?,DAY_OF_WEEK_IN_MONTH=?,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=23,SECOND=0,MILLISECOND=?,ZONE_OFFSET=?,DST_OFFSET=?]

//GregorianCalendar对象.get(Calendar.各种参数)、
Calendar time01=new GregorianCalendar();   //创建GregorianCalendar对象
int int01=time01.get(Calendar.MONTH);  //获取time01中的MONTH（月份）参数
System.out.println(int01);   //输出月份

2  //月份用0-11表示

//传参：要修改哪类参数 ，要改成多少
Calendar time01=new GregorianCalendar(2022,2,26,21,10,1);   //创建GregorianCalendar对象
time01.set(Calendar.MONTH,1);  // 把time01的MONTH参数改为1
int int01=time01.get(Calendar.MONTH);   //获取time01中的MONTH（月份）参数
System.out.println(int01);

1

//传参：要增加哪类参数，要增加多少 可以为负数
Calendar time01=new GregorianCalendar(2022,2,26,21,10,1); //创建GregorianCalendar对象
time01.add(Calendar.MONTH,1);  // 把time01的MONTH参数增加1 
int int01=time01.get(Calendar.MONTH);  //获取time01中的MONTH（月份）参数
System.out.println(int01);

3

//无需传参
Calendar time01=new GregorianCalendar(2022,2,26,21,10,1);   //创建GregorianCalendar对象
Date time02=time01.getTime();//把time01转化为Date类
System.out.println(time02);

Tue Apr 26 21:10:01 CST 2022

import java.util.Random;

//无需传参
Random int01=new Random();  //创建名为int01的Random类对象

 //无需传参  
Random int01=new Random();    //创建名为Random类对象
double int02=int01.nextDouble();  //获取double类型的随机数
System.out.println(int02);  //输出随机数

//无需传参 
Random int01=new Random();  //创建名为Random类对象
double int02=int01.nextFloat();   //获取float类型的随机数
System.out.println(int02);   //输出随机数

0.3593621850013733

// 不传参时
Random int01=new Random();   //创建名为Random类对象
double int02=int01.nextInt();  //获取0-1的随机数
System.out.println(int02);  ////输出随机数

//传参时 
Random int01=new Random();   //创建名为Random类对象
double int02=int01.nextInt(10);  //获取0-10的随机数
System.out.println(int02);  ////输出随机数

1.444571128E9
9.0

//无需传参
Random int01=new Random();   //创建名为Random类对象
System.out.println(int01.nextBoolean());  //输出boolean类型的随机数

false

public class Test02 {
    public static void main(String[] args) {
        Test03<String> a=new Test03<>();  //创建String类容器
        a.set("abc",2);   //使用 set方法
        System.out.println(a.get(2)); //使用get方法
    }
}
//使用泛型E传递类型参数 
class Test03<E>{
    Object[] s=new Object[5]; //定义可接收任何类型的数组
    void set(E a,int b){   //创建为方法设置值的方法
        s[b]=a;
    }
    E get(int i){      //创建获取值的方法
        return (E)s[i];  //把Object类型转化为E代表的类型
    }
}

ArrayList<String> a=new ArrayList();  //创建ArrayList容器类存储String对象

ArrayList<String> a=new ArrayList();  //创建ArrayList容器类存储String对象
System.out.println(a.size());   //打印容器元素个数

ArrayList<String> a=new ArrayList();  //创建ArrayList容器类存储String对象
a.add("123");  //增加字符串123
System.out.println(a.size());  //打印容器元素个数

ArrayList<String> a=new ArrayList();   //创建ArrayList容器类存储String对象
System.out.println(a.isEmpty());  //查看容器是否为空

ArrayList<String> a=new ArrayList();   //创建ArrayList容器类存储String对象
a.add("123"); //添加字符串
a.add("456");  //添加字符串
a.remove(0);  //移除a中索引为0的元素的内存地址
System.out.println(a.size());  //打印容器元素个数

//传参：传入一个类型，初始化的Set对象为这个这个类型的容器
Set<String> a=new HashSet<>();  //初始化一个String容器

Set<String> a=new HashSet<>();
a.add("你好");  //添加String值
a.add("我也好");
a.add("你好");   //向容器添加重复的值
System.out.println(a);

[你好, 我也好]  //因为值不可重复的特性，第三次的add方法没有生效

//传参：无需传参
Set<String> a=new HashSet<>();
a.add("你好");
System.out.println(a.size());

//传参：无需传参
Set<String> a=new HashSet<>();
a.add("你好");
System.out.println(a.isEmpty());

//传参：传入要移除的对象名
Set<String> a=new HashSet<>();
a.add("你好");
a.remove("你好");
System.out.println(a.isEmpty());

//传参：传入另一个Set对象
Set<String> a=new HashSet<>();
a.add("你好");
Set<String> b=new HashSet<>();
b.add("我好");
a.addAll(b);
System.out.println(a);

[我好, 你好]

//传参：传入另一个Set对象
Set<String> a=new HashSet<>();
a.add("你好");
a.add("我好");
Set<String> b=new HashSet<>();
b.add("我好");
a.removeAll(b);
System.out.println(a);

[你好]

//传参：传入某种类型
Set<Integer> a=new TreeSet<>();

//传参： 传入要创建时指定类型的对象
Set<Integer> a=new TreeSet<>();
a.add(3);
a.add(2);
System.out.println(a);

[2, 3] //自动进行了排序

import java.util.Map;

import java.util.HashMap;

//传参：传入泛型 第一个参数是键，第二个是值
HashMap<Integer,String> a=new HashMap();
//存入a的键和值，需要是Integer和String的对象

//传参：传入创建对象时传入的泛型的对象
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");  //放入键值对把键设为1值设为"hello"

//传参：传入已经存入集合的键
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
System.out.println(a.get(1));

hello

//传参：传入键
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
a.remove(1);  // 移除键值对1,"hello"
System.out.println(a.get(1));

//传参：键名
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
System.out.println(a.containsKey(1));

//传参：值名
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
System.out.println(a.containsValue("hello"));

true

//传参：无需传参
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
System.out.println(a.size());

//传参：无需传参
HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
System.out.println(a.isEmpty());

// 传参：另一个容器对象
HashMap<Integer,String> a=new HashMap();
HashMap<Integer,String> b=new HashMap();
a.put(1,"hello"); 
b.put(2,"word");
a.putAll(b);  //把b里的键值对加到a里面去
System.out.println(a.size());  //查看a的键值对数量

HashMap<Integer,String> a=new HashMap();
a.put(1,"hello");
a.clear();  //清空容器
System.out.println(a.size());  //查看a的键值对数量

//传参：传入两个泛型类
TreeMap<Integer,String> a=new TreeMap<>();

TreeMap<Integer,String> a=new TreeMap<>();
a.put(3,"你好");

//创建一个ArrayList并往里面添加元素
List<String> a=new ArrayList<>();
a.add("1");
a.add("2");
a.add("3");
//使用迭代器遍历容器
for (Iterator<String> b=a.iterator();b.hasNext();){
    String x=b.next();  //让b指向下一个元素，如果不加这句会进入死循环
    System.out.println(x);
}
//Iterator<String> b=a.iterator()对容器对象使用iterator() 方法获得迭代器对象，前面声明时<>里的参数应该与容器存储的类型一致
//b.hasNext()用于检测容器里还有没有下一个元素

1
2
3

//创建Map容器并添加键值对 
Map<Integer,String> a=new HashMap<>();
a.put(1,"1");
a.put(2,"2");
a.put(3,"3");
//遍历容器节点
Set<Map.Entry<Integer,String>> x=a.entrySet();   //转化为Set对象
for (Iterator<Map.Entry<Integer,String>> b = x.iterator(); b.hasNext();){  //声明时传入Map.Entry<Integer,String>类型 ，其他与List遍历容器一致
    Map.Entry<Integer,String> h=b.next();   //让b指向下一个节点，如果不加这句会进入死循环 
    System.out.println(h.getKey()+h.getValue());  //在使用时可以把h容器当作普通Map节点使用
}

11
22
33

//创建Map容器并添加键值对
Map<Integer,String> a=new HashMap<>();
a.put(1,"1");
a.put(2,"2");
a.put(3,"3");
////遍历容器所有的键
Set<Integer> x=a.keySet();  //获得所有键组成的Set
for (Iterator<Integer> b = x.iterator(); b.hasNext();){
    Integer h=b.next(); //让b指向下一个键
    System.out.println(h+"--"+a.get(h));  //通过键键获取值
}

//传参：容器对象
//创建数组列表
List<String> a=new ArrayList<>();
a.add("4");
a.add("2");
a.add("3");
//对数组列表排序
Collections.sort(a);
System.out.println(a);

//传参：容器对象
//创建数组列表
List<String> a=new ArrayList<>();
a.add("4");
a.add("2");
a.add("3");
//对数组列表随机排序
Collections.shuffle(a);
System.out.println(a);

//传参：容器对象
//创建数组列表
List<String> a=new ArrayList<>();
a.add("4");
a.add("2");
a.add("3");
//对数组列表颠倒顺序
Collections.reverse(a);
System.out.println(a);

//传参：从哪个容器找，要找的值 
//创建数组列表
List<String> a=new ArrayList<>();
a.add("4");
a.add("2");
a.add("3");
//查找数组列表的某个值的位置
System.out.println(Collections.binarySearch(a,"3"));

import java.text.DateFormat;  //导入DateFormat类
import java.text.SimpleDateFormat; //导入DateFormatSimpleDateFormat类

//   传参： 定义格式，以字符串形式
//方法一 不设置格式，如果不定义格式，转化后默认为 yy-MM-dd aahh:mm
DateFormat time01=new SimpleDateFormat();
//方法二 设置格式
DateFormat time01=new SimpleDateFormat("yyyy-MM-dd"); // 参数中的yyyy不能随便选择字母代替，应该符合下表的规则，参数中的-和yyyy、MM的先后顺序可以自由改变

//传入时间对象进行格式化
DateFormat time01=new SimpleDateFormat("yyyy-MM-dd");  //设置要转化成的格式
String str01=time01.format(new Date());  //对时间对象进行格式化
System.out.println(str01);   //输出格式化以后的时间

2022-03-26

// 传参 ：按照SimpleDateFormat对象设置的格式传参
DateFormat time01=new SimpleDateFormat("yyyy-MM-dd");  //设置传入参数的格式
Date time02=time01.parse("2022-3-26");  //按照yyyy-MM-dd的格式传入字符串
System.out.println(time02);  //打印时间对象

Sat Mar 26 00:00:00 CST 2022

类名 对象名=类名.now();

import java.time.Instant;

//使用 now方法
Instant time01=Instant.now();   //创建名为time01的Instant类对象
System.out.println(time01);

2022-03-27T08:33:09.011Z  //格林威治时间

//传参： ZoneId对象
Date time02=new Date();  // 创建Date对象
Instant time03=time02.toInstant();  //把Date对象转化为Instant
ZonedDateTime time04=time03.atZone(ZoneId.systemDefault());   //把Instant对象转化为ZonedDateTime

import java.time.Duration;

import java.time.Period;

//传参 ： 年、月、日
Period  time01=Period.of(1,2,3);  //设置time01时长为1年2个月3天

//使用 now方法
LocalDate time02=LocalDate.now();   //创建名为time02的LocalDate类对象
System.out.println(time02);

2022-03-27

//  传参：年、月、日
LocalDate time02=LocalDate.of(2012,6,27);   //创建2012年6月27日的时间
System.out.println(time02);

2012-06-27

//增加时间
LocalDate time02=LocalDate.of(2012,6,27);

LocalDate time04=time02.plus(Period类对象) //加上Period类对象包含的时间
LocalDate time04=time02.plusDays(1);  //对time02增加1天时间
System.out.println(time04);
LocalDate time04=time02.plusWeeks(1);  //对time02增加1周时间
System.out.println(time04);
 LocalDate time04=time02.plusMonths(1); //对time02增加1月时间
System.out.println(time04);
LocalDate time04=time02.plusYears(1);    //对time02增加1年时间
System.out.println(time04);

//减去时间
LocalDate time04=time02.minus(Period类对象) //减去Period类对象包含的时间
LocalDate time04=time02.minusDays(1);//对time02减去1天时间
System.out.println(time04);
LocalDate time04=time02.minusWeeks(1);//对time02减去1周时间
System.out.println(time04);
LocalDate time04=time02.minusMonths(1);//对time02减去1月时间
System.out.println(time04);
LocalDate time04=time02.minusYears(1);//对time02减去1年时间
System.out.println(time04);

2012-06-28
2012-07-04
2012-07-27
2013-06-27
    
2012-06-26
2012-06-20
2012-05-27
2011-06-27

import java.time.LocalTime;

//使用 now方法
LocalTime time03=LocalTime.now();  //创建名为time03的LocalTime类对象
System.out.println(time03);

16:33:09.050

//传参： 时、分、秒、纳秒
LocalTime time03=LocalTime.of(6,5,40,240);   //创建时间为6点5分40秒240纳秒的时间对象
System.out.println(time03);

06:05:40.000000240

LocalTime time03=LocalTime.of(6,5,40,240);

//增加时间
LocalTime time04=time03.plusNanos(1); //对time03增加1纳秒
System.out.println(time04);
LocalTime time04=time03.plusSeconds(1);//对time03增加1秒
System.out.println(time04);
LocalTime time04=time03.plusMinutes(1);//对time03增加1分钟
System.out.println(time04);
LocalTime time04=time03.plusHours(1);//对time03增加1小时
System.out.println(time04);

//减去时间
LocalTime time04=time03.minusNanos(1); //对time03减去1纳秒
System.out.println(time04);
LocalTime time04=time03.minusSeconds(1);//对time03减去1秒
System.out.println(time04);
LocalTime time04=time03.minusMinutes(1); //对time03减去1分钟
System.out.println(time04);
LocalTime time04=time03.minusHours(1);//对time03减去1小时
System.out.println(time04);

06:05:40.000000241
06:05:41.000000240
06:06:40.000000240
07:05:40.000000240
    
06:05:40.000000239
06:05:39.000000240
06:04:40.000000240
05:05:40.000000240

//使用 now方法
LocalDateTime time04=LocalDateTime.now();  //创建名为time04的LocalDateTime类对象
System.out.println(time04);

2022-03-27T16:33:09.050

//传参方式一：年、月、日、时、分、秒、纳秒
 LocalDateTime time04=LocalDateTime.of(2012,6,27,6,5,40,240);
//传参方式二：LocalDate对象、LocalDateTime对象
LocalDate time02=LocalDate.now();   //现在年月日
LocalTime time03=LocalTime.now();  //现在时、分、秒、纳秒
LocalDateTime time04=LocalDateTime.of(time02,time03); //现在时间的LocalDateTime对象
//传参方式三 年、月份枚举类、日、时、分、秒、纳秒
LocalDateTime time04=LocalDateTime.of(2012,Month.APRIL,27,6,5,40,240);

Month int01=Month.of(1);
System.out.println(int01);

JANUARY

//传参：  ZoneId对象
LocalDateTime time04=LocalDateTime.of(2012,6,27,6,5,40,240); //设置时间对象
ZonedDateTime time06=time04.atZone(ZoneId.of("Europe/Paris")); //使用ZoneId.of()方法生成ZoneId对象传入
System.out.println(time06);

2012-06-27T06:05:40.000000240+02:00[Europe/Paris]

  LocalDateTime time04=LocalDateTime.of(2012,5,27,6,5,40,240);
//增加 传参： 加多少个  ChronoUnit枚举类型
LocalDateTime time05=time04.plus(1, ChronoUnit.DAYS); //增加1个1天
System.out.println(time05);

LocalDateTime time05=time04.minus(1, ChronoUnit.DAYS);//减少1个1天
System.out.println(time05);

2012-04-28T06:05:40.000000240
2012-04-26T06:05:40.000000240

import java.time.temporal.ChronoUnit;

//方法一  传参 ：将某项值修改成多少 

LocalDateTime time04=LocalDateTime.of(2012,Month.APRIL,27,6,5,40,240);  //创建对象
//1.修改纳秒的值
LocalDateTime time05=time04.withNano(1);  //把纳秒数改成1
System.out.println(time05);
//2.修改秒的值
LocalDateTime time05=time04.withSecond(1);  //把秒数改成1
System.out.println(time05);
//3.修改分钟的值 
LocalDateTime time05=time04.withMinute(1);//把分钟数改成1
System.out.println(time05);
//4.修改小时的值
LocalDateTime time05=time04.withHour(1);//把小时数改成1
System.out.println(time05);
//5.修改本月的第几日
LocalDateTime time05=time04.withDayOfMonth(1);  //把日期改成本月第1天
System.out.println(time05);
//6.修改今年的第几日
LocalDateTime time05=time04.withDayOfYear(1);  //把日期改成今年第1天
System.out.println(time05);
//7.修改月份的值
LocalDateTime time05=time04.withMonth(1); //把月份改成1月
System.out.println(time05);
//8.修改年份的值
LocalDateTime time05=time04.withYear(1);  //把年份改成1
System.out.println(time05);

//方式二  传参：ChronoField枚举类对象和要改的值
LocalDateTime time04=LocalDateTime.of(2012,Month.APRIL,27,6,5,40,240);
LocalDateTime time05=time04.with(ChronoField.YEAR,1);  //修改年份为1
System.out.println(time05);

0001-04-27T06:05:40.000000240

import java.time.temporal.ChronoField;

//方法三使用   with方法并传入  TemporalAdjuster调节器对象  
//使用过程比较繁琐这里不予展示具体使用方法

// 传参：DateTimeFormatter枚举类对象
LocalDateTime time01=LocalDateTime.now();   //创建对象
String str1=time01.format(DateTimeFormatter.BASIC_ISO_DATE);  //获得格式化以后的字符串
System.out.println(str1);  //输出字符串

20220328

import java.time.format.DateTimeFormatter;

LocalDateTime time01=LocalDateTime.now();  //创建LocalDateTime对象
String str1=time01.format(DateTimeFormatter.ISO_DATE_TIME); //转化为字符串
LocalDateTime time02=LocalDateTime.parse(str1);  //转化回LocalDateTime
System.out.println(time02);  //输出LocalDateTime对象

2022-03-28T23:33:10.585

//  传入DateTimeFormatter对象
LocalDateTime time01=LocalDateTime.now();  //创建对象
String str1=time01.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")); //调用DateTimeFormatter.ofPattern()方法 传入格式字符串获得设置好格式的DateTimeFormatter对象
System.out.println(str1);

2022-03-28

//使用 now方法
ZonedDateTime time05=ZonedDateTime.now();  //创建名为time05的ZonedDateTime类对象
System.out.println(time05);

2022-03-27T16:33:09.050+08:00[Asia/Shanghai]

//传参方式一  LocalDate对象 LocalTime对象 ZoneId对象(时区id)
//传参方式二  年、月、日、小时、分钟、秒、纳秒  ZoneId对象(时区id)
//传参方式三  LocalDateTime对象  ZoneId(时区id)
LocalDate time02=LocalDate.of(2012,6,27);
LocalTime time03=LocalTime.of(6,5,40,240);
ZonedDateTime time05=ZonedDateTime.of(time02,time03, ZoneId.of("Europe/Paris"));  //使用ZoneId.of()方法传入ZoneId生成ZoneId对象

import java.util.Set;

Set<String> ZoneId01=ZoneId.getAvailableZoneIds();  //创建ZoneId的集合
for (String a:ZoneId01){    //循环输出
    System.out.println(a);}  

Asia/Aden
America/Cuiaba
Etc/GMT+9
Etc/GMT+8
Africa/Nairobi
America/Marigot
Asia/Aqtau
Pacific/Kwajalein
America/El_Salvador
Asia/Pontianak
Africa/Cairo
……………………………………  //太长，不列出所有结果

ZoneId id01=ZoneId.systemDefault();  //获取系统ZoneId
System.out.println(id01);

Asia/Shanghai

//传参：  ZoneId对象
ZonedDateTime time05=ZonedDateTime.of(2012,6,27,6,5,40,240, ZoneId.of("Europe/Paris"));  //创建ZonedDateTime对象
ZonedDateTime time06=time05.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));//修改创建ZonedDateTime对象时区
System.out.println(time06);            

2012-06-27T12:05:40.000000240+08:00[Asia/Shanghai]

//传参：Instant对象 和  ZoneId对象
Calendar time01=Calendar.getInstance();  //创建Calendar对象
TimeZone zone01=time01.getTimeZone();    //获取TimeZone对象，要先导入TimeZone类
ZoneId zone02=zone01.toZoneId();         //获取ZoneId对象
ZonedDateTime time02=ZonedDateTime.ofInstant(time01.toInstant(),zone02)  //转化为ZonedDateTime对象

import java.util.TimeZone;

//使用 now方法
Year time01=Year.now();     //创建名为time01的Year类对象
System.out.println(time01);

2022

//使用 now方法
YearMonth time02=YearMonth.now();   //创建名为time02的YearMonth类对象
System.out.println(time02);

2022-03

//使用 now方法
MonthDay time03=MonthDay.now();    //创建名为time03的MonthDay类对象
System.out.println(time03);

//传参：年份
MonthDay md=MonthDay.now();
LocalDate  ys=md.atYear(2022);
System.out.println(ys);

2022-06-23

//传参：MonthDay对象
MonthDay md=MonthDay.now(); //创建对象
MonthDay md1=md.withDayOfMonth(30); //修改日期，原MonthDay对象不变返回一个新MonthDay对象
MonthDay md2=md1.withMonth(5); //修改月份，原MonthDay对象不变返回一个新MonthDay对象
System.out.println(md2);  //输出修改后的月份
System.out.println(md.compareTo(md2)); //比较修改后的日期，md大则返回正数，md2大则返回负数

--05-30
1

//传参：(path)文件路径 , 反斜杠要用转义符转义
File f1=new File("F:\\记录\\212.75.206.107.har");
System.out.println(f1);

//传参：File类对象
File f1=new File("F:\\记录\\218.75.206.107.har");
f1.renameTo(new File("F:\\记录\\abc"));

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
f1.createNewFile();  //根据对象路径生成文件，文件不存在则创建

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
System.out.println(f1.exists());   //反回boolean值，这里直接向控制台输出

true

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");   //传入对象路径
System.out.println(f1.isDirectory());   //反回boolean值，这里直接向控制台输出

false

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");   //传入对象路径
System.out.println(f1.isFile());   //反回boolean值，这里直接向控制台输出

true

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
System.out.println(f1.lastModified());  //获得从1970到最后一次修改时间的毫秒数

1648703753295

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
System.out.println(f1.length());  //反回字节数

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
System.out.println(f1.getName());   //反回文件名（带格式后缀）

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
System.out.println(f1.getPath());   //反回传入对象路径
System.out.println(f1.getAbsolutePath()); //反回文件绝对路径
System.out.println(f1.getparent()); //反回父路径，如果没有则返回null

F:\记录\ab.txt
F:\记录\ab.txt
F:\记录

//传参：无需传参
File f1=new File("F:\\记录\\ab.txt");  //传入对象路径
f1.delete();  //删除文件

 //方法一  传参：无需传参
File f1=new File("F:\\记录\\01");   //传入对象路径
boolean x1=f1.mkdir();  //创建路径F:\\记录\\01  中路径末端的01文件夹，如果记录文件夹不存在则会创建失败
System.out.println(x1)

true

 //方法二  传参：无需传参
File f1=new File("F:\\记录\\02\\03");   //传入对象路径
boolean x1=f1.mkdirs();   //创建路径 F:\\记录\\02\\03  中路径末端的03文件夹，如果02或者记录文件夹不存在则会创建02或者记录文件夹
System.out.println(x1)

//无需传参
File f1=new File("F:\\记录");  //传入对象路径
File[] f2=f1.listFiles();    //获取路径下的文件和文件夹的File对象储存在数组里
for (File f:f2){
	System.out.println(f);   //循环输出文件获文件夹名
}

F:\记录\01
F:\记录\02

File f1=new File("F:/记录");
f1.list();   //获取列表名
for (String a:f1.list()){
    System.out.println(a);
}

01
02   

public class Test01 {
    public static void main(String[] args) throws IOException {
        Test01 x1=new Test01();
        File n1=new File("F:\\记录");  //以 F:\\记录 文件夹为例
        x1.muck(n1,0);
        }


    private void muck(File file,int a){

        File[] f01=file.listFiles();
        a++;     //每次被调用时将a加1
        for (File f1:f01){
            if (f1.isDirectory()){
                for (int i=0;i<a;i++) System.out.print("—— ");  //打印——线以区分目录结构
                System.out.println(f1.getName());  //打印当前目录
                muck(f1,a);
            }else {
                for (int i=0;i<a;i++) System.out.print("—— ");  //打印——线以区分目录结构
                System.out.println(f1.getName());  //打印当前文件
            }
        }
    }
}

//传参：需要传入File类对象或文件路径
File f1=new File("F:/记录/01.txt");
InputStream f2=new FileInputStream(f1);

//方法一：单字节读取
//传参：无需传参
File f1=new File("F:/记录/01.txt"); //01.txt是一个utf8格式的内容只有一个“123456789”的文件
InputStream f2=new FileInputStream(f1);
int a=f2.read();   //默认读文件的一个字节，返回读取到的值
//源文件是什么格式的就读到什么格式编码的字节
System.out.println((char) a);  //读到的是utf8编码的“1”，输出时转回char类型

1

//方法二，多字节读取
File f1=new File("F:/记录/01.txt");  //01.txt是一个utf8格式的内容只有一个“123456789”的文件
InputStream f2=new FileInputStream(f1);
byte[] x=new byte[3];  //创建一个长度为三的byte数组
int a=f2.read(x);   //读取文件，把读取到的字节，存进数组，读取的字节个数与数组长度一致，返回读到的字节个数
for (byte i:x){   //循环打印读到的字节
System.out.println((char) i);}
System.out.println(a);   //打印读到的字节个数

//构造传参：传入File对象，、boolean值（可选参数）：true为追加模式，默认为false：会在写入前清空文件内容
File f1=new File("F:/记录/01.txt"); //创建File对象
OutputStream f2=new FileOutputStream(f1);  //创建输出流对象

//构造传参：创建时传入File对象，、boolean值（可选参数）：true为追加模式，默认为false：会在写入前清空文件内容
//写入传参：写入时传入byte数组对象
File f1=new File("F:/记录/01.txt");  //创建File对象。若不纯在则创建文件
OutputStream f2=new FileOutputStream(f1);  //传入File对象，还有一个可选参数，传入boolean值，ture为追加模式，默认false，重写模式
String a="你好";   //要写入文件的内容
byte[] x=a.getBytes(StandardCharsets.UTF_8); //转化为byte数组
f2.write(x,0,x.length);  //传入要写入的byte数组，开始位置，结束位置
f2.flush(); //强制把内存中驻留的字节刷入硬盘
f2.close(); //关闭流

//传参：传入File对象
File f1=new File("F:/记录/01.txt");
Reader f2=new FileReader(f1);

//传参：File对象，char数组
File f1=new File("F:/记录/01.txt"); //创建File对象
Reader f2=new FileReader(f1);  //传入File对象
char[] x=new char[1024];  //创建缓冲容器
int m=f2.read(x);  //从文件中读取与缓冲容器大小一样的字符个数，并放入char数组，m为读到的字符个数
String b=new String(x,0,m);  //把char数组中的字符转化为字符串
System.out.println(b); //打印字符串
f2.close();  //关闭流

你好

//传参：File对象
File f1=new File("F:/记录/01.txt");
Writer n=new FileWriter(f1);

//构造传参：File对象、boolean值（可选参数）：true为追加模式，默认为false：会在写入前清空文件内容
//写入传参：write(char)写入单个字符 
//write(char[])写入整个字符数组
//write(char[],off,len)写入字符数组的一部分，off：开始位置：len：结束位置
//write(String)写入字符串
//write(String,off,len)写入字符串的一部分
File f1=new File("F:/记录/01.txt");  //创建File对象
Writer n=new FileWriter(f1);  //传入File对象
String str1="你也好";  //要写入的字符串
char[] ca1=str1.toCharArray();  //转化为char数组
n.write(ca1,0, ca1.length); //写入文件，可直接传入
n.flush();  //强制把内存中驻留的字节刷入硬盘
n.close();  //关闭流

//传参：byte数组对象
ByteArrayInputStream a = new ByteArrayInputStream(str);

byte[] str="今天很开心".getBytes(); //要存入内存的字符串（可以是其他东西）
byte[] str2=new byte[20]; //用于存放读取时字节的数组
ByteArrayInputStream a = new ByteArrayInputStream(str); //把字符串存入内存
int m=a.read(str2); //读取内存中的字符串存入str2，m为读到的字节数
String x=new String(str2,0,m);   //把字节转化为字符串
System.out.println(x); //向控制台打印

//传参：无需传参
ByteArrayOutputStream a=new ByteArrayOutputStream();

//传参：byte数组，起始位置，结束位置
byte[] str="今天很开心".getBytes(); ////要存入内存的字符数组
ByteArrayOutputStream a=new ByteArrayOutputStream(); //创建类对象
a.write(str,0,str.length);  //写入字符数组
a.flush(); //强制把内存中驻留的字节刷入硬盘
byte[] txt=a.toByteArray(); //获取类对象中的字符数组
System.out.println(new String(txt,0,txt.length)); //转化为字符串，并打印结果
a.close(); //关闭流

// 传参:FileOutputStream对象
File f1=new File("F:/记录/01.txt");
try (BufferedOutputStream a = new BufferedOutputStream(new FileOutputStream(f1))) {  //初始化BufferedOutputStream对象，用try-With-resources环绕的字节流不需要手动关闭流
    byte[] str1 = "今天又是吃土的一天".getBytes(StandardCharsets.UTF_8); //创建字节数组
    a.write(str1, 0, str1.length); //写入
    a.flush();   //强制把内存中驻留的字节刷入硬盘
}

//传参：FileInputStream对象
File f1=new File("F:/记录/01.txt");
try (BufferedInputStream a = new BufferedInputStream(new FileInputStream(f1))){  //初始化BufferedInputStream对象，，用try-With-resources环绕的字节流不需要手动关闭流
   byte[] str1 =new byte[50]; //创建存放读取到的内容的字节数组
   int x=a.read(str1);  //读取文件，x为读取到的字节数
   System.out.println(new String(str1,0,x));  //向控制台输出读取到的内容
}

今天又是吃土的一天

//传参：FileWriter对象
File f1 = new File("F:/记录/01.txt");
try (BufferedWriter a = new BufferedWriter(new FileWriter(f1))) {  //创建BufferedWriter对象 
    a.write("今天不吃土", 0, 5);  //写入第一行文字
    a.newLine();                //换行
    a.append("去吃树叶");        //写入第二行文字   
    a.flush();                 //强制把内存中驻留的字节刷入硬盘
}    //用try-With-resources环绕的字节流不需要手动关闭流

//传参:FileReader对象
File f1=new File("F:/记录/01.txt");
BufferedReader a=new BufferedReader(new FileReader(f1));   //初始化BufferedReader对象
String b=a.readLine();   //读取a指向的文件的一行，存在变量b中
String c=a.readLine();    //读取a指向的文件的二行，存在变量c中
System.out.println(b);  //输出b
System.out.println(c);  //输出c

今天不吃土
去吃树叶

ObjectOutputStream su=new ObjectOutputStream(new FileOutputStream("F:/02.txt")); //创建对象
int a=5;        //要序列化的值
su.writeInt(a);   //使用writeInt方法序列化int值在底层自动把int类型转化为了Integer对象，Integer类默认实现了Serializable接口
su.writeUTF("你好");  //使用writeUTF方法序列化String对象，String类默认实现了Serializable接口
su.close();  //每次用完要记得关哦

ObjectInputStream si=new ObjectInputStream(new FileInputStream("F:/02.txt")); //创建对象
int s=si.readInt();         //要反序列化的int值
System.out.println(s);     //输出值
System.out.println(si.readUTF());  //要反序列化的String值
si.close();  //记得关闭流

Properties ad=new Properties();

//传参：Reader子类对象或InputStream子类对象
Properties ad=new Properties();  //  创建Properties类对象
ad.load(new FileReader("src/com/abc.properties")); //加载当前项目下的文件

//传参：输出流对象
Properties ad=new Properties();  //  创建Properties类对象
ad.load(new FileReader("src/com/abc.properties")); //加载当前项目下的文件
ad.list(System.out);  //向标准输出流（屏幕）输出配置文件的所有内容

//传参：key值
Properties ad=new Properties();  //  创建Properties类对象
ad.load(new FileReader("src/com/abc.properties"));  //加载当前项目下的文件
System.out.println(ad.getProperty("fv"));  //向屏幕输出key为fv的值

1651

//传参：key值，value值
Properties ad=new Properties(); //创建Properties类对象
ad.setProperty("fg","123");  //向Properties类对象中修改指定key的value值，若key不存在则新增key和value值
ad.store(new FileWriter("./ed.properties"),null);   //将修改完的Properties对象保存到指定的路径文件中，若不存在则创建路径指定的文件名并把Properties对象中所有的key和value值写入

io对象.close();

Reader子类对象.read();

Writer对象.write();

输出流对象.flush();

字节输入流对象.read();

字符输出流对象.write();