java基础.md · 靳海阳/Guava-case

### 1.函数式编程思想

面向对象思想需要关注用什么对象完成什么事情，而函数式编程思想就类似于我们数学中的函数，它主要关注的是**对数据进行了什么操作**。（核心是数据）

函数式编程的优点：

①代码简洁易读（公司都在用）

②大数据量集合易于提高效率（实现并行流处理十分简单）

### 2.Lambda表达式

#### 2.1 概述

Lambda是JDK8中的一个语法糖，它可以对某些匿名内部类的写法进行简化，是函数式编程思想的重要体现。

它**只关心参数和函数体**，也就是函数式编程的核心思想，**只关注对什么数据进行了什么操作**。

#### 2.2 核心原则

```tex
可推导可省略（如果参数的类型可以推导出来，就可以省略类型；如果方法名可以推导出来，就可以省略方法名）
```

#### 2.3 基本格式

```java
(参数列表)->{函数体}
```

#### 2.4 例子

不使用Lambda表达式简化：

```java
 //创建线程并启动，不使用Lambda表达式
new Thread(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程运行。。。。");
	}
}).start();
```

使用Lambda表达式：

```java
//创建线程并启动，使用Lambda表达式
new Thread(()->{
	System.out.println("线程运行lambda.....");
}).start();
```

可以使用Lambda的原因是：Runnable接口是**函数式接口**（有且仅有一个抽象方法的接口）-->接口名、方法名可以推导-->可省略

```java
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
```

### 3.java IO

程序运行时，将数据从硬盘或网络输入内存进行处理，再将数据从内存输出到硬盘或网络。在java中依靠IO流实现。

#### 3.1 组成

在java api中，IO可以分为两部分：**字节流(InputStream/OutputStream)**和**字符流(Reader/Writer)**

字节流：用来读入或写出**字节序列**的流（传输数据最小单位为字节byte）

字符流：其读入和写出操作都是基于两字节的char值(即Unicode码元)，而不是基于byte值(传输数据最小单位为字符char)

▲unicode由两字节组成（每个字符用两个字节表示，范围0-65535）

Reader和Writer传输数据的时候，其实也是对字节的传输。可以将Reader和Writer看为有编解码功能的InputStream和OutputStream

几个基本接口：

（1）**java.io.Closeable**

- void close()

关闭这个Closeable，用来释放其持有的资源

（2）**java.io.Flushable**

- void flush()

把缓冲区的内容强制写出，主要用在IO中，用来清除缓冲区数据。

eg：一般我们在写数据的时候，数据是先被读到内存中，再把数据写到文件中，当数据读完的时候不代表你的数据已经写完了（可能有一部分数据留在了缓冲区中），这时如果调用close()方法关闭流，那么缓冲区部分的数据就会丢失。所以必须**在关闭流的之前调用flush()**

（3）**java.lang.Readable**

-  int read(CharBuffer cb)

向cb中读入其持有数量的char值，返回读入char值的数量。当从这个Readable中无法再获得更多char时返回-1

（4）**java.lang.Appendable**

- Appendable append(char c)
- Appendable append(CharSequence csq)

- Appendable append(CharSequence csq, int start, int end)

向这个Appendable中追加给定的码元或者给定序列中所有的码元(可以指定起始和结束位置)

（5）**java.lang.CharSequence**

- char charAt(int index)

返回给定索引处的码元

- int length()

返回这个序列中码元的数量

- CharSequence subSequence(int start, int end);

返回[start,end)中所有码元组成的CharSequence

- String toString()

返回这个序列中所有码元组成的字符串

![字节字符流实现的接口](E:\java项目\Guava学习\guava-case\images\字节字符流实现的接口.png)

#### 3.2 装饰者模式

装饰者模式属于**结构型模型**，

**目的：**向一个现有的对象添加新的功能，而不改变其结构。

**实现方式：**创建一个装饰类，用来包装原有的类，并在保持方法签名完整性的前提下，提供额外功能

eg：女生化妆例子（不同化妆品有不同的效果，女生通过自己组合不同化妆品来实现最终效果）

要装饰的方法接口Showable：

```java
public interface Showable {
    //标准展示行为
    public void show();
}
```

女生类，实现showable接口

```java
public class Girl implements Showable{
    @Override
    public void show() {
        System.out.print("女生的素颜");
    }
}
```

装饰者的抽象类，持有被装饰者并直接调用被持有者方法（装饰者抽象类不进行任何装饰，由其子类进行装饰）

```java
public abstract class Decorator implements Showable{
    //持有被装饰者
    protected Showable showable;

public Decorator(Showable showable) {
        this.showable = showable;
    }

//装饰器抽象类直接调用其持有者方法
    //其具体如何装饰交由子类进行
    @Override
    public void show() {
        showable.show();
    }
}
```

具体装饰类1，继承装饰者抽象类，实现自己的装饰方法

```java
public class FoundationMakeup extends Decorator{

public FoundationMakeup(Showable showable) {
        super(showable); //调用抽象父类的构造注入
    }

//子类装饰器，实现自己特有的装饰方法
    @Override
    public void show() {
        System.out.print("打粉底【");
        super.show();
        System.out.print("】");
    }
}
```

具体装饰类2，继承装饰者抽象类，实现自己的装饰方法

```java
public class Lipstick extends Decorator{

public Lipstick(Showable showable) {
        super(showable);
    }

@Override
    public void show() {
        System.out.print("涂口红【");
        super.show();
        System.out.print("】");
    }
}
```

客户端通过new(new ())的形式使用即可

```java
public class Client {
    public static void main(String[] args) {
        //先打粉底，再涂口红(装饰器实现层层包裹)
        Lipstick makeupGirl = new Lipstick(new FoundationMakeup(new Girl()));
        makeupGirl.show();
    }
}
//涂口红【打粉底【女生的素颜】】
```

类图：

![装饰者模式类图](E:\java项目\Guava学习\guava-case\images\装饰者模式类图.png)

▲**通过new(new ())多层嵌套很可能使用的就是装饰者模型**

#### 3.3 FileInputStream和FileOutputStream入门

InputStream和OutputStream是抽象类，最基本子类就是FileInputStream和FileOutputStream

```java
public class FileInputOutputStreamCase {

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

//1.文件输入流
        FileInputStream inputStream = new FileInputStream("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\sourceFile.txt");
        //存储读出来的字节
        List<Byte> bytes = new ArrayList<>();
        Byte val;
        //read()方法一次读取一个字节，返回值为该字节的值；当返回值为-1，表示读取结束
        while ((val = (byte) inputStream.read())!= -1){
            bytes.add(val);
        }

//将读出来的字节转为字符串输出
        byte[] array = new byte[bytes.size()];
        for (int i = 0; i < bytes.size(); i++) {
            array[i] = bytes.get(i);
        }
        System.out.println(new String(array));
        inputStream.close();

//2.文件输出流
        FileOutputStream outputStream = new FileOutputStream("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\TargetFile.txt");
        outputStream.write("hello java".getBytes("UTF-8"));
        //flush刷新
        outputStream.flush();
        outputStream.close();
    }
}
```

可以看出，字节输入输出流操作起来比较麻烦，得一个字节一个字节进行处理

#### 3.4 IO中的装饰者模式

![IO中的装饰者模式](E:\java项目\Guava学习\guava-case\images\IO中的装饰者模式.png)

eg：CheckedInputStream是一个具体的装饰者，其作用：

①输入流，读入数据

②维护正在读取的数据的校验和。然后可以使用校验和来验证输入数据的完整性

```java
public int read() throws IOException {
    //调用被装饰者的read()方法
    int b = in.read();
    //自己多加的装饰业务，检查数据完整性
    if (b != -1) {
        cksum.update(b);
    }
    return b;
}
```

#### 3.5 写出器PrintWriter和读入器Scanner

**PrintWirter**类拥有以文本格式打印字符串和数字的方法。对于打印文件，需要用文件名和字符编码构建一个PrintStream对象

（1）控制台输出

```java
//1.使用PrintWriter(写出器)进行控制台打印
@Test
public void consoleLog(){
    //System.out为输出流PrintStream
    //true表示设置写出器为自动冲刷模式(冲刷缓冲区)
    PrintWriter printWriter = new PrintWriter(System.out,true);
    printWriter.println(1);
}
```

相当于：System.out.println(1);

（2）文件输出

```java
//2.使用PrintWriter进行文件写出
@Test
public void testPrintWriter() throws FileNotFoundException, UnsupportedEncodingException {
    PrintWriter printWriter = new PrintWriter("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\targetFile.txt", "UTF-8");
    String name = "海阳";
    int age = 25;
    double salary = 10000000.1;
    printWriter.print("name: " + name);
    printWriter.print("age: " + age);
    printWriter.println("salary: " + salary);
    printWriter.close(); //必须关闭，否则文件中没有数据
}
```

（3）控制台输入

```java
//3.使用Scanner读取控制台的输入
public static void main(String[] args) {
	//System.in是输入流InputStream
    Scanner sc = new Scanner(System.in);
    while (sc.hasNext()){
        System.out.println(sc.next());
    }
}
```

（4）文本输入

```java
//4.使用Scanner读取文件输入
@Test
public void scannerFile() throws FileNotFoundException {
    Scanner sc = new Scanner(new File("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\sourceFile.txt"));
    while (sc.hasNext()){
        String s = sc.nextLine();
        System.out.println(s);
    }
}
```

#### 3.6 读写二进制数据(DataInput和DataOutput)

文本格式对于测试和调试而言是方便的，因为它是人类可以阅读的，但它并不像以二进制格式传递数据那样高效。

DataInput和DataOutput接口定义了用二进制格式读写数据，eg：writeInt(int i)总是将一个整数写出为4字节的二进制数据，而不管它有多少位。这样产生的结果并非人类可以阅读的，但是对于给定类型的每个值，使用的空间是相同的，将其读回也比解析文本要快。

```java
public static void main(String[] args) throws IOException {
    //二进制输出流DataOutputStream
    DataOutputStream outputStream = new DataOutputStream(new FileOutputStream("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\targetFile.txt"));
    outputStream.writeByte(100);
    outputStream.writeShort(200);
    outputStream.writeInt(300);
    outputStream.writeLong(400L);
    outputStream.writeFloat(456F);
    outputStream.writeDouble(99.99);

//二进制输入流DataInputStream
    DataInputStream inputStream = new DataInputStream(new FileInputStream("E:\\java项目\\Guava学习\\guava-case\\guava-case\\src\\main\\resources\\io\\targetFile.txt"));
    System.out.println(inputStream.readByte());
    System.out.println(inputStream.readShort());
    System.out.println(inputStream.readInt());
    System.out.println(inputStream.readLong());
    System.out.println(inputStream.readFloat());
    System.out.println(inputStream.readDouble());
    //关闭流
    outputStream.close();
    inputStream.close();
}
```

以二进制方式写出，同时以二进制方式写入，就和如何编码无关了。。

靳海阳/Guava-case

简介

发行版

贡献者

近期动态

靳海阳/Guava-case .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

靳海阳/Guava-case