corejava流的笔记

Java IO流的基本知识●对一下几个类的理解：⏹类File⏹类FileInputStream:类 FireOutputStream :BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符，数组和行的高效读取。

通常采用此操作时常常将BufferedReader包装其所有read()操作以提高开销很高的Reader(如FileReader ,Inputstream Reader)。

具体实现：BufferdReader br = new BufferdReader (new FileReader(“Sharon.text”)); “Sharon.text”为文件名BufferedWriter:将文本将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。

在大多数情况下，默认值就足够大了。

该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。

并非所有平台都使用新行符 ('\n') 来终止各行。

因此调用此方法来终止每个输出行要优于直接写入新行符。

通常 Writer 将其输出立即发送到底层字符或字节流。

除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。

例如，PrintWriter out= new PrintWriter(new BufferedWriter(newFileWriter("foo.out")));⏹DataInputStream:数据输入流允许应用程序对于底层输入流中基本数据的读取。

⏹DataInputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。

java高级知识点笔记以下是一些Java高级知识点的笔记：1. 泛型（Generics）：泛型是Java 5中引入的一个新特性，它允许在编译时定义类型参数化的类、接口和方法。

使用泛型可以提高代码的可重用性和可读性，并减少类型转换的错误。

2. 注解（Annotations）：注解是Java提供的一种元数据机制，用于为代码添加元信息。

注解本身不改变程序的执行逻辑，但可以通过反射机制在运行时读取注解中的信息，对程序进行配置、跟踪、调试等操作。

3. 并发编程（Concurrency）：Java提供了丰富的并发编程工具，包括线程（Thread）、锁（Lock）、并发集合（ConcurrentHashMap、CopyOnWriteArrayList等）、并发包（包）等。

使用这些工具可以帮助开发人员编写高效的多线程程序。

4. 反射（Reflection）：反射是Java提供的一种机制，可以在运行时动态地获取类的信息，包括类的方法、属性、注解等。

反射可以用于实现动态代理、插件架构、框架开发等场景。

5. 泛型与类型擦除（Type Erasure）：泛型在编译时会进行类型擦除，将类型参数替换为具体的类型。

类型擦除是为了保持与旧版本的兼容性，但也带来了一些限制，例如不能在运行时获取泛型类型信息。

6. 泛型通配符（Wildcards）：泛型通配符是Java泛型的一个高级特性，它允许使用未知类型作为参数，增加了泛型的灵活性。

7. Lambda表达式：Lambda表达式是Java 8中引入的一个新特性，它允许以简洁的方式表示匿名函数式接口的实现。

Lambda表达式可以用于实现函数式编程风格，提高代码的可读性和可维护性。

8. Stream API：Stream API是Java 8中引入的一个新特性，它提供了一种声明式的方式来处理集合数据。

Stream API可以帮助开发人员以函数式编程的方式对集合进行转换、过滤、映射等操作。

IO流总结IO（Input Output）流●IO流用来处理设备之间的数据传输●Java对数据的操作是通过流的方式●Java用于操作流的对象都在IO包中●流按操作数据分为两种：字节流与字符流。

●流按流向分为：输入流，输出流。

输入流和输出流的流向的理解？流就是处理数据的一种方式或者一种手段，或者理解为一种数据流。

从硬盘已有的数据读取出来放存里面的这个过程就是输入流。

把存中的数据存储到硬盘中的这个过程就是输出流。

简单理解就是：以存为中心。

什么时候使用流对象？操作设备上的数据或操作文件的时候可以使用。

字符流字符流的抽象基类：Reader ， Writer。

字符流的理解，由来和作用？由于很多国家的文字融入进来，比如说中文在编码表中默认占2个字节。

而为了按照文字的单位来处理，所以出现了字符流。

由来：早期的字节流+编码表，为了更便于操作文字数据。

作用：为了处理文字数据。

复制文件的原理和代码。

原理：首先用一个读取流对象和一个文件进行关联，然后用一个写入流对象作为目地的，为了把读取流中的文件传输到目的地流对象中，我们就提供了一个字符数组，为了关联这个数组，所以读取流对象有一个read()方法与这个字符数组进行关联，同理，写入流对象也有一个write()方法与这个字符数组进行关联，这样2个流对象就相连接了，而这个字符数组就相当于一个中转站。

import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** 对文本文件进行复制。

将c盘的文件复制到d盘中。

* 原理：其实就是一个最简单的读写过程。

* 从c盘源，读取数据，并将读到的数据，写入到目的d盘中。

*/public class CopyTextFileTest {public static void main(String[] args) {FileReader fr = null;FileWriter fw = null;try {//1,创建一个字符读取流读取与源数据相关联。

第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中，通过JVM寄存器读取⽂件中的⾏号，进⾏执⾏相关代码；注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明，它不会被编译成代码执⾏，只是起到⼀个描述作⽤，便于对代码的理解；Java中的注释分为3种：单⾏注释：//多⾏注释：/* */⽂档注释：/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；规范：每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；**规范：**1.严格区分⼤⼩写；2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成，但数字不能⽤于开始；4.不可以包含特殊字符；5.不能以Java语⾔中的保留字作为命名；6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串；注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排for(int j = i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。

诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。

面向过程的基本单元是函数。

什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。

能够做什么（方法）：告诉外界对象有那些功能。

后者以前者为基础。

大的对象的属性也可以是一个对象。

为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。

对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。

方法的定义非常重要。

方法有参数，也可能有返回值。

注意区分：对象（本身）、对象的实现者、对象的调用者。

分析对象主要从方法开始。

我们通过类来看待对象，类是对象的抽象。

其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。

对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。

这样才能使每个对象本身做成最好的。

对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。

实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。

可复用性是OOP的基础。

比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。

面向过程是先有算法，后有数据结构。

面向对象是先有数据结构，然后再有算法。

在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。

开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。

从语法上来看，一个类是一个新的数据类型。

在面向对象编程中，除了简单数据类型，就是对象类型。

定义类的格式：class Student{代码}注意类名中单词的首字母大写。

实例变量：定义在类中但在任何方法之外。

（New出来的均有初值）局部变量：定义在方法之中的变量。

局部变量要先赋值，再进行运算，而实例变量均已经赋初值。

这是局部变量和实例变量的一大区别。

java完美经典读书笔记第一章概述第二章JAVA语言基础关键字：基本数据类型：bytehortintcharlongfloatdoubleboolean循环控制：dowhileforbreakcontinue分支控制：ifelewitchcaedefaultbreak方法变量和类得修饰府：privatepublicprotectedfinaltaticabtractynchronizedvolatiletrictf ptranient字面值常量：faletruenull方法相关得关键字：returnvoid包相关得关键字：packageimport异常处理：trycatchfinallythrowthrow对象相关：newe某tendimplementuperclaintanceofthi很多算术运算操作可以产生浮点型无法表达的数字，如无限大，无限小等，这些数据的表达通过浮点数封装类（Float和Double）所提供的特殊属性来表达。

Float.NaN非数字Float.NEGATIVE_INFINITY无限小Float.POSITIVE_INFINITY无限大Double.NaN非数字Double.NEGATIVE_INFINITY无限小Double.POSITIVE_INFINITY无限大数据类型的自动转换图：char--->{int-->long-->float-->doublebyte-->hort-->{内置类对应的基本类型：Byte-->byte;Short-->hort;Integer-->int;Long-->long;Float-->float;Double-->doubleBoolean-->boolean;Character-->char;String-->char[]将基本数据类型转为String类型：tringtr1;intintv1=300;tr1=String.valueOf(intv1);将tring类型转为基本数据类型：tringtr1="126";inti1=Integer.pareInt(tr1);取得tring对象内含的char[]值，必须使用它的toCharArray()方法来取得。

java基础知识总结笔记对于很多只会C语言的初学者而言，面对java基础语法学习，反而感觉很难，其实其中最大的问题不是语法难，而是一种编程思想的转变。

下面是为大家的关于java基础知识总结笔记，希望大家喜欢!Java基础入门学习路线可以总结为四步走：1.java开发环境的搭建;2.java初级之基础语法学习(80%类似C语言);3.java中级之面向对象编程学习(重点);4.java中级之应用编程学习。

第一步：JDK软件开发包时java软件开发环境，包括jre运行环境和jvm虚拟机，在oricle官网下载javaSE 版本JDK包;配置好环境变量就可以使用了。

第二步:java初级语法学习，1.基本数据类型整形，字符型，字节型，长整形，短整形，浮点型，双精度，布尔型;2.运算符+，-，*，/，%等;3.控制流(while,switch，ifelse);4.数组的定义方式。

此阶段基本无难度，只要了解练习例题。

第三步:java面向对象学习，1.类和对象;2.java语言三大特性，封装、继承、多态;3.一些关键字学习(static，final，abstract,extends)等。

这是重点，大家根据知识点一步步研究学习才是关键。

第四步：java应用编程，例如：文件IO，集合(类似C语言数据结构)，异常处理，线程，网络，JDBC数据库操作等，都是掌握面向对象以后，在查找不同的类使用类中不同的方法达到应用的效果，所以并不会很难。

等基础语法掌握了就可以继续后面框架学习(javaweb方向，android学习)，相信明确思路你会豁然开朗，更有学习动力。

以上没有具体的实例和知识点讲解，分享的只是完全没接触过java的初学者自学java的思路和学习的流程，应该把握的重点，希望大家有所帮助。

1991年Sun公司的JamesGosling(詹姆斯·高斯林)等人开始开发名称为Oak的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器;1994年将Oak语言更名为Java;Java的三种技术架构:JAVAEE：JavaPlatformEnterpriseEdition，开发企业环境下的应用程序，主要针对web程序开发;JAVASE：JavaPlatformStandardEdition，完成桌面应用程序的开发，是其它两者的基础;JAVAME：JavaPlatformMicroEdition，开发电子消费产品和嵌入式设备，如手机中的程序;1，JDK：JavaDevelopmentKit，java的开发和运行环境，java 的开发工具和jre。

1.输入InputStream，输出OutputStream以字节为单位存取相对于内存/管道来说OutputStream(write)内存----------------------------------> 硬盘文件管道内存<---------------------------------- 硬盘文件InputStream(read)2.FileOutputStream f =new FileOutputStream("tarena.txt");//如果之前有这文件，将会覆盖FileOutputStream f =new FileOutputStream("tengbx.txt",true); //如果有这文件，只会追加3.处理字节流的两个基础类是：InputStream OutputStrean处理字符流的两个基础类是：Reader Writer1.InputStream 和 OutputStream（抽象类，以字节为单位进行读写）1)InputStream介绍：->InputStream in = new FileInputStream("file.txt");byte[] buf = new byte[in.available()];int count = in.read(buf);in.close();int read()读取一个字节，并返回读取的字节数int read(byte[] buffer)将数据读入一个字节数组，同时返回读取的字节数int read(byte[] buffer,int offset,int length)将数据读入一个字符数组，放到数组的offset指定的位置开始，并用length指定读取的最大字节数void close():用完流以后一定要关闭int available():用于返回在不发生阻塞的情况下，该流可以读取的字节数2)OutputStream 介绍：write(int c):写入一个字节到流中write(byte[] buffer):将字节数组中的数据写入到流中int write(byte[] buffer,int offset,int length)将字节数组中从offset开始的length个字节写入流中。

java学习笔记（5）控制语句、键盘输⼊控制语句：java控制可以分为7种：*控制选择结构语句： *if if else *switch*控制循环结构语句： *for *while *do while*改变控制语句顺序： *break *continueif控制语句：/*关于java语⾔当中的if语句，属于选择结构，if语句⼜被称为分⽀语句/条件控制语句；1、if语句的运发结构：包含4中编写⽅式第⼀种：if(布尔表达式){java语句;...};第⼆种：if(布尔表达式){java语句;...}else{java语句;...}第三种：if(布尔表达式){java语句;...}else if(布尔表达式){java语句;...}...第四种：if(布尔表达式){java语句;...}else if(布尔表达式){java语句;...}else{java语句;...}重点：只要有⼀个if分⽀执⾏，整个if语句结束；注意：所有控制语句都是可以互相嵌套的。

注意：嵌套使⽤的时候，代码格式要保证完美。

注意：if语句中，只有⼀条java语句的话，⼤括号可以省略；if(true/false){java语句;}if(true/false) java语句;//但是不推荐使⽤，这种代码风格不好。

不容易看清。

*/public class ifTest01{public static void main(String[] args){// 需求，所在位置的5公⾥范围内有肯德基的话，去KFC吃午饭。

// 公⾥数double distance = 6.0;//单位KM// 判断语句if(distance<=5){System.out.println("⾛着去KFC吃午饭");}else if(distance<=7.0&&distance>5){System.out.println("跑着去KFC吃午饭");}else{System.out.println("在附近吃别的");}}}接收⽤户键盘输⼊：/*System.out.println() 负责向控制台输出，【从内存到控制台，输出的过程，这是从内存中出来了】接收⽤户键盘输⼊，从"键盘"到"内存"。

java中的各种流（⽼师的有道云笔记）内存操作流-字节之前的⽂件操作流是以⽂件的输⼊输出为主的，当输出的位置变成了内存，那么就称为内存操作流。

此时得使⽤内存流完成内存的输⼊和输出操作。

如果程序运⾏过程中要产⽣⼀些临时⽂件，可采⽤虚拟⽂件⽅式实现；直接操作磁盘的⽂件很耗性能,使⽤内存流可以提升性能;jdk⾥提供了内存流可实现类似于内存虚拟⽂件的功能。

•ByteArrayInputStream：将内容写到内存中•ByteArrayOutputStream：将内存中的数据写出ByteArrayInputStream：构造⽅法：•public ByteArrayInputStream(byte[] buf):全部内容•public ByteArrayInputStream(byte[] buf,int offset,int length)：指定范围的内容ByteArrayOutputStream:•public ByteArrayOutputStream()public class ByteArrayDemo { public static void main(String[] args) throws Exception { String info = "helloworld"; InputStream input = new ByteArrayInputStream(info.getBytes()); OutputStream output = new ByteArrayOutputStream(); int temp = 0; while ((temp = input.read()) != -1) { output.write(Character.toUpperCase((char) temp)); } String str = output.toString(); // 取出内容 input.close() ;//关闭⽆⽤ output.close() ;//⽆效 System.out.println(str) ; }}打印流思考：如果现在要想完成⼀个字符串或者是boolean型或者是字符型的数据输出使⽤OutputStream是否⽅便？肯定是不⽅便的，因为OutputStream中只能操作字节数据，所以其他的数据类型很难操作，那么在Java的IO包中为了解决这种问题增加了两种类：PrintStream、PrintWriter。

Java核⼼技术卷⼆笔记2第⼆章输⼊与输出本章是对输⼊输出相关API的介绍输⼊/输出流在Java API中，可以从其中读⼊⼀个字节序列的对象称作输⼊流，可以向其中写⼊⼀个字节序列的对象称为输出流。

字节序列的来源地和⽬的地可以是⽂件、⽹络连接和内存块等。

以Unicode形式存储的信息使⽤⼀个单独的类进⾏处理，它的读⼊写出操作是基于两字节的Char值，即Unicode码元，⽽不是字节。

读写字节InputStream类有⼀个read抽象⽅法，OutputStream类有⼀个write抽象⽅法，具体的输⼊输出流类需要覆盖⽅法以提供功能。

这两个⽅法执⾏时都会阻塞，available⽅法可以检查当前可读⼊的字节数量。

完成读写操作后，应调⽤close⽅法关闭，关闭输出流时还会冲刷关于该输出流的缓冲区，该冲刷操作会将缓冲区中的内容送出，若不关闭⽂件可能会导致缓冲区中的内容⼀直都⽆法传递出。

组合输⼊/输出流过滤器FileInputStream和FileOutputStream提供关于磁盘⽂件的输⼊输出流，对这两个类的构造器传⼊⽂件路径时，注意传⼊的路径中的分隔符需要使⽤双反斜杠进⾏转义。

可以发现传⼊正斜杠时代码也不报错，但并不建议这样做。

此外，对于可移植的程序应使⽤java.io.File.separator作为分隔符。

每种过滤器各司其职，在实际使⽤中需要将其嵌套结合，如为了读取增加了缓冲机制的⽂件中的数字。

DataInputStream din = new DataInputStream(new BufferedInputStream(new FileInputStream("employee.dat")));⽂本输⼊与输出⽂本输⼊输出时需要在构造器中传⼊编码⽅式。

⽂本输出器PrintWriter的构造⽅法中第三个参数是代表是否⾃动冲刷，若⾃动冲刷，则println被调⽤时缓冲区中的所有字符就会被发送到⽬的地。

《Java核⼼技术》读书笔记（1-5章）+= 是右结合运算符枚举类型：变量只能存储这个类型声明中给定的某个枚举值，或者null，表⽰没有设置任何值。

switch，如果case匹配不上会调⽤defaultfor循环中注意浮点数的判断for(double i=0,i!=10,i+0.1){sout{i}}Arrays是⼀个类，包含操作数组的静态⽅法如toString，sort，equal，binarySearch⼆维数组实际上是⼀个特殊的数组，第⼀个索引是数组的内存中的位置，第⼆个是该数组的元素索引。

隐式参数，如this，⽅法的调⽤者，如this。

显⽰参数，传递的参数。

类的静态域是所有实例共享静态⽅法使⽤的场景不需要访问对象状态⼀个⽅法只需要访问类的静态域⽅法参数使⽤不能修改⼀个基本数据类型的参数可以改变⼀个对象的参数状态不能让对象参数引⽤⼀个新的对象，⽆法实现交换功能⼀个构造器可以调⽤另⼀个// 使⽤thispublic Employee(double s){this("employee",s);nextId++}super1. 调⽤⽗类的⽅法2. 调⽤⽗类构造器，只能是第⼀条构造器，如果参数不⼀致编译报错私有域⽗类不能直接使⽤⼦类private私有域。

⽅法覆盖在覆盖⼀个⽅法的时候，⼦类⽅法不能低于超类⽅法的可见性。

如果超类⽅法时public修饰，⽽⼦类遗漏了该修饰符，那么编译器会把它解释为试图提供更严格的访问权限。

阻⽌继承final关键字修饰类，只有其⽅法被⾃动的成为final，⽽不包括域。

内联早期java中，有些程序员为了避免动态绑定的带来的系统开销⽽使⽤final关键字，⽽如果⼀个⽅法没有被覆盖并且很短，编译器就能够对他进⾏优化处理，这个过程称为内联。

强转在超类转换成⼦类前，应该⽤instanceof进⾏检查。

如何有效的定义equals1. 判断this==otherObject2. 判断otherObject==null3. 判断getClass==otherObject.getClass()4. 判断私有域的值是否⼀致ArrayListensureCapacity设定了⼀个值可以加快arrayList初始化时间add⽅法添加，set⽤来替换，如果不存在会报错public void demoTest01(){ArrayList<String> list = new ArrayList<>(3);list.set(0,"3");}ng.IndexOutOfBoundsException: Index: 0, Size: 0装箱拆箱包装类由于每个值分别包装在对象中，所有ArrayList<Integer>的效率远远低于int[]数组，适⽤于⼩型集合。

JavaIO流学习总结Java流操作有关的类或接⼝：Java流类图结构：流的概念和作⽤流是⼀组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。

即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，⽅便更直观的进⾏数据操作。

IO流的分类根据处理数据类型的不同分为：字符流和字节流根据数据流向不同分为：输⼊流和输出流字符流和字节流字符流的由来：因为数据编码的不同，⽽有了对字符进⾏⾼效操作的流对象。

本质其实就是基于字节流读取时，去查了指定的码表。

字节流和字符流的区别：读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，⼀次可能读多个字节。

处理对象不同：字节流能处理所有类型的数据（如图⽚、avi等），⽽字符流只能处理字符类型的数据。

结论：只要是处理纯⽂本数据，就优先考虑使⽤字符流。

除此之外都使⽤字节流。

输⼊流和输出流对输⼊流只能进⾏读操作，对输出流只能进⾏写操作，程序中需要根据待传输数据的不同特性⽽使⽤不同的流。

Java IO流对象1.输⼊字节流InputStream IO 中输⼊字节流的继承图可见上图，可以看出：1. InputStream 是所有的输⼊字节流的⽗类，它是⼀个抽象类。

2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地⽂件中读取数据。

PipedInputStream 是从与其它线程共⽤的管道中读取数据，与Piped 相关的知识后续单独介绍。

3. ObjectInputStream 和所有FilterInputStream 的⼦类都是装饰流（装饰器模式的主⾓）。

2.输出字节流OutputStreamIO 中输出字节流的继承图可见上图，可以看出：1. OutputStream 是所有的输出字节流的⽗类，它是⼀个抽象类。

Java流操作有关的类或接口：Java流类图结构：流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。

即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类•根据处理数据类型的不同分为：字符流和字节流•根据数据流向不同分为：输入流和输出流字符流和字节流字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象。

本质其实就是基于字节流读取时，去查了指定的码表。

字节流和字符流的区别：•读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

•处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。

除此之外都使用字节流。

输入流和输出流对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

Java IO流对象1.输入字节流InputStream IO 中输入字节流的继承图可见上图，可以看出：1.InputStream 是所有的输入字节流的父类，它是一个抽象类。

2.ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。

PipedInputStream是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。

3.ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

2.输出字节流OutputStreamIO 中输出字节流的继承图可见上图，可以看出：1.OutputStream 是所有的输出字节流的父类，它是一个抽象类。

Java核⼼技术-读书笔记基本语法Java中的所有函数都属于某个类的⽅法Java没有任何⽆符号的int、long、short 或 byte 类型浮点数值不适⽤于⽆法接受舍⼊误差的⾦融计算中，⽐如2.0-1.1不会输出想要的0.9，如果不允许有任何舍⼊误差，应该使⽤BigDecimal类建议不要在程序中使⽤char类型，除⾮确实需要处理UTF-16的代码单元，最好将字符串作为抽象数据类型处理boolean类型：整数和布尔值之间不能相互转换利⽤final指⽰常量，只能赋值⼀次，⼀旦被赋值后，就不能更改了类常量：希望某个常量可以在⼀个类中的多个⽅法中使⽤，⽤ static final 设置，如果⼀个常量被声明为 public 那么其他类⽅法也可以使⽤这个常量，const是java的保留关键词，但并没有使⽤操作符：>>>运算符会⽤0填充⾼位，这与>>不同，它会⽤符号位填充⾼位，不存在<<<运算符字符串：String.subtring，+，String.join等等String类没有提供⽤于修改字符串的⽅法，不能修改Java字符串中的字符，可以提取⼦串后拼接，String不可变，StringBuilder可变⼀定不要使⽤==运算符检测两个字符串是否相等，它只能判断两个字符串是否在放置在同⼀个位置上，可以⽤equals或compareTo空串是长度为0的字符串，是⼀个java对象，null则不是⽐C++多了带标签的break: ⽬的是跳出嵌套的深层循环，标签必须放在希望跳出的最外层循环之前，并紧跟⼀个冒号，通过执⾏带标签的break跳转到带标签语句块的末尾，if语句也同样使⽤，但不能跳⼊语句块，只能跳出Java没有提供运算符重载的功能，除了字符串拼接的 +java.math包中的BigInteger和BigDecimal类可以处理包含任意长度数字序列的数值，实现了任意精度的整数和浮点数运算数组：将⼀个数组变量拷贝给另⼀个数组变量，两个变量将引⽤同⼀个数组int[] a = b;a[5] = 12; // now b[5] is also 12如果希望将⼀个数组的所有值拷贝到另⼀个新的数组中，需要使⽤Arrays类的copyOf⽅法OOP算法+数据结构 = 程序⾯向过程往往先考虑算法实现，然后考虑数据存储⾯向对象是相反的过程，将数据放在第⼀位，才考虑操作数据的算法⾯对⼀个需求，先从设计类开始，然后再往类中添加⽅法。

FileWriter向磁盘写入文件package t2s01.t2s01;importjava.io.FileWriter;importjava.io.IOException;public class FileWriter1 {/*需求：将一段中文数据写到硬盘上。

思路：1，写到硬盘上，也就是将内存中的数据搞到硬盘上，应该是输出流。

2，操作的是中文，因该是字符流。

3，结合两者，需要输出流，需要字符流，联想到使用字符输出流Writer。

4，具体用抽象类Writer哪个子类呢？硬盘上用于存储数据的体现：文件File。

找到了具体的对象java.IO/FileWriter*/public static void main(String[] args) throws IOException {/** 1，通过java.IO/FileWriter创建流对象。

* 必须通过构造函数明确写入数据需要存储的位置。

该对象一创建，目的文件就会被创建。

* 如果该文件已经存在，会被覆盖。

*///FileWriterfw=new FileWriter("k\\demo.txt");//异常：IOExceptionFileWriterfw=new FileWriter("demo.txt");//将demo.txt文件写入当前的文件包下/*2，从类java.io.Writer继承的方法。

调用写入方法* 此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。

*/fw.write("中文");fw.flush();//刷新该流的缓冲。

fw.write("你好");//3，关闭流资源fw.close();////fw.write("guanbi");//java.io.IOException: Stream closed/** flush()和close()有什么区别？* flush():仅将缓冲中的数据刷新到目的地。

java从入门到精通读书笔记(一)Java从入门到精通笔记入门篇•熟悉Java发展历史•安装JDK、Eclipse•编写Hello World程序•了解Java基本语法•掌握变量、数据类型、运算符、控制语句面向对象编程•了解面向对象的特点•掌握类和对象的概念•学习继承、封装、多态等基本概念•实现类的定义和对象的创建•学习重载和重写集合和IO•学习Java中的容器类•掌握ArrayList、HashSet、HashMap等集合的使用•熟悉Java中的IO操作•了解文件操作、序列化等内容网络编程•掌握socket通信•理解TCP/IP协议•学习HTTP协议•实现客户端和服务器高级Java特性•学习反射、注解等高级特性•掌握多线程编程•熟悉JVM架构•学习异常处理JavaWeb编程•掌握Servlet、JSP等技术•学习MVC框架•熟悉Web应用服务器•学习数据库编程总结•学习Java需要不断积累•遇到问题可以通过搜索引擎解决•不断实践，多写代码•持续学习新技术，保持竞争力入门篇Java语言是面向对象的编程语言，是一种广泛使用的计算机编程语言。

Java语言从1996年开始被发布，现在已被广泛应用于客户端和服务器端程序的开发。

在学习Java之前，需要先了解Java的发展历史。

安装JDK、EclipseJava的开发需要安装JDK和Eclipse。

JDK是Java开发工具包，其中包含了Java编译器等工具。

Eclipse是一款常用的Java IDE(集成开发环境)，可以用于编写，调试和运行Java代码。

编写Hello World程序在学习Java语言之前，需要先学会编写Hello World程序，这是一个非常简单的程序，可以帮助初学者快速上手Java编程。

public class HelloWorld {public static void main(String[] args){System.out.println("Hello World!");}}了解Java基本语法Java是一种强类型的语言，需要对数据类型进行明确的定义。