Java基础个人学习整理

原创

开始喜欢风 2023-03-03 06:35:56 ©著作权

文章标签 java 操作数 System Java 文章分类 HarmonyOS 后端开发

©著作权归作者所有：来自51CTO博客作者开始喜欢风的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java基础笔记整理
—James Gosling

可以做什么：开发网站，Android开发，大数据，

计算机（computer）：硬件（Hardware）和软件（Software）（系统软件和应用软件）组成

计算机语言：机器语言，汇编语言，高级语言

JDK（Java Development kit）：Java开发工具包，开发Java程序所需要的工具以及JRE

JRE（Java Runtime Environment）：包含运行Java程序所需类库

JVM（Java Virtual Machine）：Java虚拟机，保证Java程序跨平台

基本配置（导读）

Java程序的最小单位是类，一个Java程序最少拥有一个类

Java程序的入口是main方法，main方法的格式是固定的：

public static void main(String[] args) {}

在控制台的输出语句：System.out.println (“要输出的内容”);

.idea和.iml是配置文件，一般可以隐藏
src是source的缩写，即我们编写的代码即源文件存放在这个目录下面
out是Java程序的输出目录，Java程序运行的时候，生成后缀名为.class的文件存放在这个目录下，点击运行按钮，生成的class文件叫做字节码文件，生成字节码文件的过程叫做编译
External Libraries即Java程序编写和运行所依赖的JDK中的类

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println ("HelloWorld");
  }
}

Java程序运行原理：源文件（.java）—javac.exe编译（JDK文件）—字节码文件（.class）—java.exe编译—结果

Java运行基础

注释分类

类型	作用
//	单行注释
/* */	多行注释
/** */	文档注释

/**
  这是我的第一个Java程序
*/
public class HelloWorld {
  //  程序主入口
  public static void main(String[] args) {
    /*
      这个是main方法实施的主体
      要实现的内容写到这里
    */
    System.out.println ("HelloWorld");
  }
}

关键字

被Java语言赋予特殊意义的单词，全部是小写，有特殊的颜色标记

常量：字符串，整数，小数，字符，布尔，空常量

变量

变量定义：数据类型变量名 = 常量 / 变量

int a = 3;

Java数据类型

基本类型：整数型（byte，short，int，long），浮点型（float，double），字符型（char），布尔型（boolean）

引用类型：类（class），接口（interface），数组（[]）

数据类型转换

自动类型转换：小类型转大类型，自动提升为大类型，运算结果是大类型

强制类型转换：byte-short-int/char-long-float-double

int a = 3;
int b = 4;
char c = (char)(a + b);

标识符

不能以数字开头
不能是关键字
严格区分大小写（类和接口首字母大写，变量和方法首字母小写，常量所有字母全部大写，包名全部小写）

运算符

算术运算符：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少1	B-- 或 --B 等于 19

赋值运算符

1 赋值运算符的定义：

赋值运算符用来为变量指定新值。

2 赋值运算符主要有两类：

一类是使用等号（=）赋值，它把一个表达式的值赋给一个变量或对象；

另一类是扩展的赋值运算符。

3 赋值运算符的格式

variableName = expression;

这里，variableName为变量名，expression为表达式。其功能是将等号右边表达式的值赋给左边的变量。

位运算符

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是0，则结果为0，否则为1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

扩展赋值运算符

操作符	描述	例子
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A等价于C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\| =	按位或赋值操作符	C \| = 2等价于C = C \| 2

关系运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

三目运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

表达式：

variable x = (expression) ? value if true : value if false

流程控制

scanner的概念：扫描器，即可以通过scanner类扫描用户在控制台录入的数据

// 第一步：导包
import java.util.ScannerDemo;

public class ScannerDemo{
  public static void main(String[] args) {
    // 创建键盘录入对象
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个整数：");
    // 接收数据
    int i = sc.nextInt(); // 此行代码执行时，控制台会等待用户输入数据
    // 把获取的数据输出
    System.out.println("i:" + i);
  }
}

顺序结构
判断结构
选择结构

if：如果（用作区间值的判断）

public class IfDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 3;
        if(a < b) {
            System.out.println("b大");
        }else if(a > b) {
            System.out.println("a大");
        }else {
            System.out.println("两个一样大");
        }
    }
}

switch：转换，切换（用作固定值的判断）

import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int week = sc.nextInt();
        switch (week){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("你是从冥王星来的吧");
                break;
        }
    }
}

循环结构

for

for(初始化语句; 判断条件语句; 控制条件语句){
    // 循环体
}
public class ForDemo {
    public static void main(String[] args) {
        for(int x = 1; x <= 5; x++){
            System.out.println("Helloworld");
        }
    }
}

while

while(判断条件语句){
    循环体语句;
    控制条件语句;     // 初始化语句可以省略，控制条件语句可以省略
}
public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5){
            System.out.println("HelloWorld");
            i++;
        }
    }
}

do_while

初始化语句
do{
    循环体语句;
    控制条件语句;
}while(判断条件语句);

死循环

for(;;){System.out.println("HelloWorld");}
while(true){System.out.println("HelloWorld");}

标号：即循环的名称，给循环定义一个标号，就可以根据需要结束或跳转到指定循环，常用于多层嵌套中

random类的简单使用

import java.util.Random;
public class Random{
  public static void main(String[] args) {
    Random r = new Random();
    int number = r.nextInt(10);   // 获取随机数的范围是0-9
    System.out.println("number" + number)
  }
}

方法和数组

方法：也叫函数，是完成特定功能的代码块，简单来说，一个方法就是一个功能，一个动作或一种行为

方法的调用：

形式参数：在定义方法时需明确方法参数的形式，比如参数的类型和个数

实际参数：调用方法时传递给方法的数据，必须符合形式参数的个数和对应未知的数据类型

public class ArgsDemo{
    /*
        定义格式:
            修饰符 返回值的类型 方法名（参数类型 参数名1, 参数名2......）{
                方法体语句;
                return 返回值;
            }
    */
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int x = sum(a, b);
        System.out.println("和为" + x);
    }
    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
}

careful—方法必须定义在类中，方法之间是平级关系，不能嵌套

方法重载：在同一个类中的多个方法，他们的方法名相同，参数列表不同，这样的情况，称为方法重载，方法重载和返回值类型无关

方法重载的功能：当实现的功能相同，但具体的实现方式不同，我们可以通过定义名称相同，参数条件不同的方法，来更好的识别和管理类的方法

数组概述

作用：存储多个数据值

定义：

数据类型[] 数组名 = new 数据类型[长度];    // 第一种定义格式，动态初始化
数据类型[] 数组名 = new 数据类型[]{1， 2， 3}    // 第二种定义格式，静态初始化
数据类型[] 数组名 = {1， 2， 3}    // 第三种定义格式

// 获取数组长度
arr.length

Java程序的内存分配：

方法区：存储可运行的class文件，包含方法，静态成员，常量等等

栈（Stack）：方法运行时使用的内存，特点是“后进先出”，即最先进入栈去的方法最后出栈，比如main方法

堆（Heap）：存储new出来的数组或对象

空指针异常：数组的值为null

对象

面向对象

面向对象思想：把关注点放在一件事或一个活动中涉及到的人或事物（也就是对象）上的思想（或思维方式）。

类：即归类，分类，是一系列具有相同属性和行为的事物的统称，由属性和行为构成

抽象：把一系列相关事物共同的属性和行为提取出来的过程

对象：某一个类事物中的某个具体存在

// 把两个类的内容放入栈里面进行运行
public class TestPhone {
    public static void main(String[] args) {
        // new后在堆里面开辟空间存放数据
        Phone phone = new Phone();
        // 实参
        phone.brand = "苹果";
        phone.model = "XS";
        phone.name = "媛媛";
        System.out.println(phone.brand);
        System.out.println(phone.model);
        System.out.println(phone.name);
        phone.call("乔布斯");
    }
}
class Phone {
    // 形参
    String brand;
    String model;
    String name;
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

封装

private：私有的，一种访问权限修饰符，用来修饰类的成员，被修饰的成员只能在本类中访问

public：公共的，访问权限修饰符，用来修饰类，成员变量，成员方法等，被修饰的内容可以在任意类中访问

this：这，这个，表示本类对象的引用，本质是一个对象，每个普通方法都有一个this，谁调用该方法，this就指向谁，解决局部变量和成员变量重名的问题

this.属性名

构造方法：也叫构造器，用来帮助创建对象的方法，准确的说，构造方法的作用是初始化对象

创建对象：new关键字创建对象，并在内存中开辟空间，然后使用构造方法（构造器）完成对象的初始化工作

Phone phone = new Phone()

标准代码：JavaBean：符合JavaBean标准的类，必须是具体的，公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法

继承

让类与类之间产生父子关系

子类拥有父类的非私有成员（成员变量，成员方法）

class father {
  ......
}
class son extends father {
  ......
}

使用场景：多个类存在相同的属性和行为时，可以将这些内容提取出来放到一个新类中，让这些类和新类产生父子关系，实现代码复用。

特点：

低内聚，高耦合，就近原则
Java使用变量规则：就近原则，有就使用，没有就去父类的成员位置找

this和super区别

this：本质是对象，实现的是本类（子类）中的值

super：本质是父类内存空间的标识，实现的是父类中的值

特点：

创建子类对象时，优先调用父类构造方法

子类构造方法的第一行，隐含语句super，用于调用父类的类默认无参构造

当父类里面无参数构造，需手动调用父类其他构造（super（））

Java中的访问权限修饰符

private：本类

默认：本类，本包，子类

protectd：本类，本包，子类

public：本类，本包，子类，其他类

方法重载和方法重写区别：

划分	方法重载	方法重写
方法名	相同	相同
参数列表	不同	相同
返回值类型	无关	相同
修饰符	无关	访问权限不小于被重写方法
定义位置	同一个类	子父类中

Java继承的特点

支持类的单继承，但是支持多层（重）继承；
支持接口的多继承；
父类的私有成员不能继承；
构造方法不能继承；
继承体现了"is a"的关系

多态

多种状态，同一对象在不同情况下表现不同的状态和行为（要有继承和实现关系，要有方法重写，父类引用指向子类对象）

使用场景：父类型变量作为参数时，可以接收任意子类对象

final关键字：不能被继承和重写，表示最终变量（常量），只能赋值一次。

static关键字：成员变量—类变量；成员方法—类方法

接口

接口就是统一的标准和规则

通过关键字interface实现

interface 接口名 {}

类和接口是实现关系，用implement表示

class 类名 implement 接口名

进阶

集合

List集合：单列集合，可重复，有序（存取顺序相同）

List list = new ArrayList();
add()   // 向集合里面添加元素
size()    // 获取集合中元素个数的方法
get()   // 获取索引的元素
    
/** 集合*/
/*  List:单列，有序*/
public class Test {
  public static void main(String[] args) {
    // 需求：往List中添加三个学生对象，然后遍历
    // 1. 创建集合对象
    List list = new ArrayList();
    // 2. 创建元素对象
    Student s1 = new Student("麝馨", 12);
    Student s2 = new Student("旭涵", 13);
    Student s3 = new Student("斯年", 11);
    Student s4 = new Student("麝馨", 12);
    // 3. 将元素对象添加到集合里面去
    list.add(s1);
    list.add(s2);
    list.add(s3);
    list.add(s4);
    // 4. 遍历集合
    // (1). 根据集合对象使用列表迭代器
    ListIterator lit = list.listIterator();
    // (2). 判断迭代器中是否有对象
    while(lit.hasNext()){
      // (3). 有就获取元素即可
      String s = (String)lit.next();
      if("b".equals(s)) {
        lit.add("java")
      }
      System.out.println(list)
    }
  }
}

collections工具类简介:对于单列集合进行操作

Integer max = Collections.max(list)

set集合：单列集合—不可重复，无序

/*  set:单列结合，不可重复，无序*/
public class Test {
  public static void main(String[] args) {
    // 需求：往List中添加三个学生对象，然后遍历
    // 1. 创建集合对象
    Set<Student> set = new Hsahset<>();
    // 2. 创建元素对象
    Student s1 = new Student("麝馨", 12);
    Student s2 = new Student("旭涵", 13);
    Student s3 = new Student("斯年", 11);
    Student s4 = new Student("麝馨", 12);
    Student s5 = new Student("麝馨", 12);
    // 3. 将元素对象添加到集合里面去
    set.add(s1);
    set.add(s2);
    set.add(s3);
    set.add(s4);
    set.add(s5);
    // 4. 遍历集合
    // (1). 根据集合对象使用列表迭代器
    Iterator<Student> it = set.Iterator();
    // (2). 判断迭代器中是否有对象
    while(lit.hasNext()){
      // (3). 有就获取元素即可
      Student s = it.next();
      System.out.println(list)
    // 增强for循环再进行遍历
    for(Student student : set) {
      System.out.println(student)
    }
    }
  }
}

map集合：双列集合

/*  map:双列集合，分为键和值*/
public class Test {
  public static void main(String[] args) {
    // 需求：往List中添加三个学生对象，然后遍历
    // 1. 创建集合对象
    Map<Integer, Student> map = new HsahMap();
    // 2. 创建元素对象
    Student s1 = new Student("麝馨", 12);
    Student s2 = new Student("旭涵", 13);
    Student s3 = new Student("斯年", 11);
    // 3. 将元素对象添加到集合里面去
    map.put(1, s1);
    map.put(2, s2);
    map.put(3, s3);
    // 根据键，获取值
    Student stu3 = map.get(3)   // 表示键为3的值
    // 4. 遍历集合
    // (1). 根据集合对象使用列表迭代器
    Set<Integer> keys = map.KeySet();
    // (2). 判断迭代器中是否有对象
    while(lit.hasNext()){
      // (3). 有就获取元素即可
      Integer key = map.next();
      Student value = map.get(key);
      System.out.println(list);
    }
  }
}

I/O流读写

字符流读数据之一次读取一个字符

/**   I/O流进行读写文件*/
/*  字符流读数据之一次读取一个字符*/
import java.io.FileNotFoundException; // 当I/O流传输有异常的时候,可用此包
import java.io.FileReader;    // 字符流读取文件
import java.io.Reader;    // 读取文件的类

public class ReaderDemo1 {
  public static void main(String[] args) throws IOException {   // 抛出异常，交给调用者处理
    // 需求：通过字符流读取文件
    // 1. 创建字符输入流对象
    Reader reader = new FileReader("reader.txt");
    // 2. 读取数据
    // int ch1 = reader.read();
    // System.out.println(ch1);
    int ch;
    while((ch = reader.read()) != -1){    // 当读到末尾的时候返回-1
      System.out.println(ch);
    }
    // 3. 释放资源
    reader.close();
  }
}

字符流读数据之一次读取一个字符数组

/*  字符流读数据之一次读取一个字符数组*/
import java.io.FileNotFoundException; // 当I/O流传输有异常的时候,可用此包
import java.io.FileReader;    // 字符流读取文件
import java.io.Reader;    // 读取文件的类

public class ReaderDemo1 {
  public static void main(String[] args) throws IOException {
    // 需求：通过字符流读取文件
    // 1. 创建字符输入流对象
    Reader reader = new FileReader("reader.txt");
    // 2. 读取数据
    char[] chs = new char[3];   // 3表示字符数组的初始长度
    // int len1 = reader.read();
    // System.out.println(chs);   // abc,当长度不等于可读取的有效字符数，可从后往前读
    // System.out.println(len1);    // 3
    int len;    // 定义一个变量，记录读取到的有效字符数
    while((len = reader.read(chs) != -1)) {
      // 将读取的内容转化成字符串
      String s = new String(chs, 0, len);   // 0是起始索引,len是有效字符数
      System.out.println(s);
    }
    // 3. 释放资源
    reader.close();
  }
}

字符流读写文件

/*  字符流读写文件*/
import java.io.FileNotFoundException; // 当I/O流传输有异常的时候,可用此包
import java.io.FileWriter;    // 字符流读取文件
import java.io.Writer;    // 读取文件的类
public class ReaderDemo1 {
  public static void main(String[] args) throws IOException {
    // 需求：通过字符流写入文件
    // 1. 创建字符输入流对象
    Writer writer = new FileWriter("writer.txt");
    // 2. 写入数据
    // (1). 一次写入一个字符
    writer.writer("麝馨");
    // (2). 一次写入一个指定的字符数组
    char[] chs = {'a', 'b', 'c', 'd', 'e'};
    writer.writer(chs);
    // 在一个字符数组里面取多少个写入
    writer.writer(chs, 0, 2)  // 0表示从哪个索引开始取值，2表示取多少个
    // 一次写一个字符串
    writer.writer("麝馨最棒");
    // 3. 释放资源
    reader.close();
  }
}

单个字符流拷贝文件

/** 字符流拷贝文件*/
/*  按单个字符读写*/
import java.io.FileReader;    // 字符流读取文件
import java.io.Reader;    // 读取文件的类
import java.io.FileWriter;    // 字符流读取文件
import java.io.Writer;    // 读取文件的类

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字符流拷贝文件，一次读写一个文件
    // 例如：将txt文件中的内容复制到txt2里面
    // 创建字符流输入对象，关联数据源文件
    Reader fr = new FileReader("reader.txt");
    // 创建字符流输出对象，关联数据源文件
    Writer fw = new FileWriter("writer.txt");
    // 定义变量，记录读取到的数据
    int len;
    // 循环读取，只要一满足条件就一直读，并将读取到的内容赋值给变量
    while((len = fr.read()) != -1){
      // 将读取到的数据写入目的地文件中
      fw.writer(len)
    }
    // 释放资源
    fr.close();
    fw.close();
  }
}

字符数组流拷贝文件

/*  按字符数组读写*/
import java.io.FileReader;    // 字符流读取文件
import java.io.Reader;    // 读取文件的类
import java.io.FileWriter;    // 字符流读取文件
import java.io.Writer;    // 读取文件的类

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字符流拷贝文件，一次读写一个文件
    // 例如：将txt文件中的内容复制到txt2里面
    // 创建字符流输入对象，关联数据源文件
    Reader fr = new FileReader("reader.txt");
    // 创建字符流输出对象，关联数据源文件
    Writer fw = new FileWriter("writer.txt");
    // 定义变量，记录读取到的数据
    char chs = new char[2048]
    int len;
    // 循环读取，只要一满足条件就一直读，并将读取到的内容赋值给变量
    while((len = fr.read(chs)) != -1){
      // 将读取到的数据写入目的地文件中
      fw.writer(chs, 0, len)
    }
    // 释放资源
    fr.close();
    fw.close();
  }
}

字符缓冲流拷贝文件的标准代码

/*  字符缓冲流拷贝文件的标准代码*/
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;    // 字符缓冲流的读取
import java.io.BufferedWriter;    // 字符缓冲流的写入

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字符流拷贝文件，一次读写一个文件
    // 例如：将txt文件中的内容复制到txt2里面
    // 创建字符流输入对象，关联数据源文件
    BufferedReader br = new BufferedReader(new FileReader("reader.txt"));
    // 创建字符流输出对象，关联数据源文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("writer.txt"));
    // 定义变量，记录读取到的数据
    int len;
    // 循环读取，只要一满足条件就一直读，并将读取到的内容赋值给变量
    while((len = br.read()) != -1){
      // 将读取到的数据写入目的地文件中
      bw.writer(len)
    }
    // 释放资源
    fr.close();
    fw.close();
  }
}

字符缓冲流之一次读写一行

/*  字符缓冲流之一次读写一行*/
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;    // 字符缓冲流的读取
import java.io.BufferedWriter;    // 字符缓冲流的写入

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字符流拷贝文件，一次读写一个文件
    // 例如：将txt文件中的内容复制到txt2里面
    // 创建字符流输入对象，关联数据源文件
    BufferedReader br = new BufferedReader(new FileReader("reader.txt"));
    // 创建字符流输出对象，关联数据源文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("writer.txt"));
    // 定义变量，记录读取到的数据
    String str;
    // 循环读取，只要一满足条件就一直读，并将读取到的内容赋值给变量
    while((str = br.read()) != null){
      // 将读取到的数据写入目的地文件中
      bw.writer(str)
      // 不能忘记换行
      bw.writer("\r\n");    // window换行
      bw.writer("\r") ;   // mac换行
      bw.writer("\n");      // Linux换行
      bw.newline();     // 针对所有操作系统
    }
    // 释放资源
    fr.close();
    fw.close();
  }
}

字节流读写一个字节

/*  字节流读写文件*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.InputStream;

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字节流拷贝文件，一次读写一个文件
    // 创建字节流读文件对象
    InputStream is = new FileInputStream("1.png");
    // 创建字节流写文件对象
    OutputStream os = new FileOutputStream("2.png");
    // 定义变量
    int b;
    // 通过循环写入文件中
    while((b = is.read()) != -1){
      os.writer(b);
    }
    // 释放资源
    is.close();
    os.close();
  }
}

字节流读写一个字节数组

/*  字节流读写字节数组*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.InputStream;

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字节流拷贝文件，一次读写一个文件
    // 创建字节流读文件对象
    InputStream is = new FileInputStream("1.png");
    // 创建字节流写文件对象
    OutputStream os = new FileOutputStream("2.png");
    // 定义变量
    byte[] b = new byte[2048];
    int len;
    // 通过循环写入文件中
    while((len = is.read(b)) != -1){
      os.writer(b, 0, len);
    }
    // 释放资源
    is.close();
    os.close();
  }
}

字节流拷贝文件的标准代码

/*  字节流拷贝文件的标准代码*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;

public class CopyFile {
  public static void main(String[] args) IOException {
    // 需求：通过字节流拷贝文件，一次读写一个文件
    // 创建字节流读文件对象
    InputStream bis = new BufferedInputStream(new FileInputStream("1.png"));
    // 创建字节流写文件对象
    OutputStream bos = new BufferedOutputStream(new FileOutputStream("2.png"));
    // 定义变量
    int len;
    // 通过循环写入文件中
    while((len = bis.read()) != -1){
      os.writer(len);
    }
    // 释放资源
    is.close();
    os.close();
  }
}

泛型

Lambda

多线程

JDBC

图形页面：推荐使用Python的tk库

上一篇：Qt网络编程笔记

下一篇：虚拟文件系统（无持久存储的文件系统），以proc和sysfs为例

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯