CSDN樵夫

1.字符串是一个不可变的数据类型，会返回新的字符串而不是在原有的字符串商做修改。
2.1.psvm是主函数快捷键
2.2.sout是输出函数快捷键
2.3.idea里全部替换的快捷键是ctrl+r
2.4.在变量后面加.var就可以自动出现变量的类型顺便给个名称

4.泛型：规范容器内的数据类型
容器<数据类型>

Set和List泛型规范是一样的
Map有一点不一样，他还是以键值对的形式作为数据类型的内容

5.IO流
按照读写的方向，分为输入流和输出流，是站在程序的角度去分析；
按照读写的内容，分为字节流和字符流；
按照流的功能不同，分为节点流和处理流；
节点流：直接连接在文件上（原始管子）
处理流：套在其他流上（净化器管子）

字节流：InputStream OutputStream
字符流：Reader Writer(使用方法基本同上)
这四个是祖宗，他们是抽象类

子类：
文件流：FileInputStream ~ 文件字节输入流
FileReader ~ 文件字符输入流
//读取文件最重要的一套写法
byte[] bytes = new byte[1024];
int len =0;
while((len=fis.read(bytes))!=-1){ ！！！！！！！！！！！！
String s = new String(bytes,0,len);
System.out.println(s);
}

如何选择：
字符流：读取文件中的文字信息
字节流：读取非文本文件

处理流：
缓冲流：带有缓冲区的数据流（可以暂时存储数据的内存空间）
转换流：
对象流：

缓冲流：
(缓冲流套在节点流上，节点流套在文件上)
BufferedInputStream ~
BufferReader （是读取文本文件最好用的方法）~使用方法如下：
File file1 = new File(“朱一龙.txt”);
File file2 = new File(“龙哥.txt”);

    BufferedReader br = new BufferedReader(new FileReader(file1));
    BufferedWriter bw = new BufferedWriter(new FileWriter(file2));
    String str = "";
    while((str=br.readLine())!=null){ //读取数据  ！！！！！！！！！！

            str=str.replace("nice龙哥","朱一龙");  //替换
            bw.write(str);
            bw.newLine();//!!!另起一行   //写到新文件
    }

    br.close();
    bw.flush();
    bw.close();

转换流：（怎么把字节流转换成字符流）
InputStreamReader
OutputStreamWriter

对象流：文件vs对象
ObjectInputStream 对象的输入流，把对象写到文件里
ObjectOutputStream 对象的输出流，把文件里的对象读出来
序列化：把一个对象转化成字节的过程
反序列化：把字节转化成对象

Exception in thread “main” java.io.NotSerializableException: smy.obj.Person
这个异常的处理方法：在java中，只需要给类添加一个实现：implements Serializable，就可以序列化一个类了

================================
多线程–>交替进行
（充分利用计算机资源，同时执行不同的操作）
1).继承Thread类，重写run()方法->创建线程要做的事；
2).实现Runnable接口，实现run()方法；
必须理解清楚：
1.继承了许多方法，像start(),
2.只是实现了接口的run()方法，没有start,怎么办呢？则需要借助Thread类，即创建了线程，但是希望启动的是我自己的Runnbale,所以要创建Runnable的对象，再把创建的线程对象指向我的Runnable,再让创建的线程start起来。
!!必须run,start
run():线程执行的时候要执行的代码
start():启动一个线程，使线程处于就绪状态

setPriority()设置优先级
sleep() 睡眠 //每隔xxx时间去执行一个xxx操作
join()让主线程等待这个子线程执行完毕，再继续执行
yield()让出CPU，让别人执行一下
interpret()打断正在睡眠的线程

线程同步:当多个线程共享一个资源的时候，我们可以在某一个线程访问到这个资源的时候，把这个资源暂时封锁，等待执行结束，释放这个锁，其他线程才可以执行。（等待其他线程释放锁，让线程更加安全）
方法 ：
1.在方法声明上添加一个synchronized关键字（表示这个方法一旦有人执行，会锁定调用这方法的对象）
2.在方法内部使用synchronized（）{}语句块，对特定的对象上锁（更推荐这种）
3.手动上锁->用的最少
private Lock lock=new ReentrantLock();
lock.lock();//上锁，使用在方法开始的地方
lock.unlock(); //释放锁，使用在方法结束的地方
StringBulider 线程不安全 没有synchronized
StringBuffer 线程安全 有synchronized（其他使用上二者没有什么区别）

ProducerAndConsumer

=========================
构造方法：在实例化对象的同时为对象的属性赋值。
泛型：（三种）
1.类名<具体的数据类型>{}
2.接口名<具体的数据类型>{}
/这个具体的数据类型可以用来声明变量：String str
new String() ->这个new后边跟的是构造方法/
3.方法的泛型
public<泛型> 返回值 方法（参数）{}
特点：方法的泛型会根据方法的参数进行改变
(例如：给方法传进去一个数组，把它改变成列表
用泛型控制数据的数据类型，使列表中的数据类型和数组中的数据类型保持一致)

===========================
通配符
?可以匹配所有数据类型
? extends 类 泛型必须是xxx的子类或xxx本身
? super 类 泛型必须是xxx的父类

============================
内部类:在一个类中，定义另一个类
1.成员内部类
把一个类定义成一个类似成员变量
2.局部内部类
在方法中声明类
3.匿名内部类
写一个没有名字的类
4.静态内部类
在成员内部类前面多一个stasic
调用方式比成员内部类舒服

=============================
枚举：取值范围是固定的，并且由程序员来进行定义
public enum 类型{
值1,
值2，
…
值n;
}
枚举的最大作用：限定变量的取值范围

1.Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
1.1Java标准库提供了Arrays.toString(数组)，可以快速打印数组内容：

2.类
定义class就是定义了一种数据类型，对应的instance是这种数据类型的实例；

class定义的field，在每个instance都会拥有各自的field，且互不干扰；

通过new操作符创建新的instance，然后用变量指向它，即可通过变量来引用这个instance；

访问实例字段的方法是变量名.字段名；

指向instance的变量都是引用变量。

3.这种把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。

向上转型实际上是把一个子类型安全地变为更加抽象的父类型；

instanceof实际上判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。

4. 继承是面向对象编程的一种强大的代码复用方式；

   Java只允许单继承，所有类最终的根类是Object；

   protected允许子类访问父类的字段和方法；

   子类的构造方法可以通过super()调用父类的构造方法；

   可以安全地向上转型为更抽象的类型；

   可以强制向下转型，最好借助instanceof判断；

   子类和父类的关系是is，has关系不能用继承。

5.Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。

6.多态

子类可以覆写父类的方法（Override），覆写在子类中改变了父类方法的行为；

Java的方法调用总是作用于运行期对象的实际类型，这种行为称为多态；

final修饰符有多种作用：

final修饰的方法可以阻止被覆写；

final修饰的class可以阻止被继承；

final修饰的field必须在创建对象时初始化，随后不可修改。

7.作用域
包作用域是指一个类允许访问同一个package的没有public、private修饰的class，以及没有public、protected、private修饰的字段和方法。

包没有父子关系，com.apache和com.apache.abc是不同的包。

8.String
~字符串比较：当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用equals()方法而不能用==。要忽略大小写比较，使用equalsIgnoreCase()方法。

~要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()。

~要把字符串转换为其他类型，就需要根据情况。例如，把字符串转换为int类型：
int n1 = Integer.parseInt(“123”); // 123

~拼接字符串：拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组：
String[] arr = {“A”, “B”, “C”};
String s = String.join("***", arr); // “A***B***C”

~String和char[]类型可以互相转换，方法是：
char[] cs = “Hello”.toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String

~System.out.println(Arrays.toString(i))将数组i直接打印出来

~拼接: String[] names = {“Bob”, “Alice”, “Grace”};
StringJoiner sj = new StringJoiner(", ", "Hello ", “!”);
for (String name : names) {
sj.add(name);
}

9.Enum实例
public class Main {
public static void main(String[] args) {
Weekday day = Weekday.SUN;
if (day.dayValue == 6 || day.dayValue == 0) {
System.out.println("Today is " + day + “. Work at home!”);
} else {
System.out.println("Today is " + day + “. Work at office!”);
}
}
}

enum Weekday {
MON(1, “星期一”), TUE(2, “星期二”), WED(3, “星期三”), THU(4, “星期四”), FRI(5, “星期五”), SAT(6, “星期六”), SUN(0, “星期日”);

public final int dayValue;
private final String chinese;

private Weekday(int dayValue, String chinese) {
    this.dayValue = dayValue;
    this.chinese = chinese;
}

@Override
public String toString() {
    return this.chinese;
}

}

10.异常
所有异常都可以调用printStackTrace()方法打印异常栈，这是一个简单有用的快速打印异常的方法。

Java使用异常来表示错误，并通过try … catch捕获异常；

Java的异常是class，并且从Throwable继承；

Error是无需捕获的严重错误，Exception是应该捕获的可处理的错误；

RuntimeException无需强制捕获，非RuntimeException（Checked Exception）需强制捕获，或者用throws声明；

不推荐捕获了异常但不进行任何处理。