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);

标识符

  1. 不能以数字开头
  2. 不能是关键字
  3. 严格区分大小写(类和接口首字母大写,变量和方法首字母小写,常量所有字母全部大写,包名全部小写)

运算符

算术运算符:

操作符

描述

例子

+

加法 - 相加运算符两侧的值

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流读写

  1. 字符流读数据之一次读取一个字符
/**   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();
}
}
  1. 字符流读数据之一次读取一个字符数组
/*  字符流读数据之一次读取一个字符数组*/
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();
}
}
  1. 字符流读写文件
/*  字符流读写文件*/
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();
}
}
  1. 单个字符流拷贝文件
/** 字符流拷贝文件*/
/* 按单个字符读写*/
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();
}
}
  1. 字符数组流拷贝文件
/*  按字符数组读写*/
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();
}
}
  1. 字符缓冲流拷贝文件的标准代码
/*  字符缓冲流拷贝文件的标准代码*/
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();
}
}
  1. 字符缓冲流之一次读写一行
/*  字符缓冲流之一次读写一行*/
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();
}
}
  1. 字节流读写一个字节
/*  字节流读写文件*/
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();
}
}
  1. 字节流读写一个字节数组
/*  字节流读写字节数组*/
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();
}
}
  1. 字节流拷贝文件的标准代码
/*  字节流拷贝文件的标准代码*/
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库