一，编程基础

最新推荐文章于 2024-09-15 09:47:04 发布

花壶得

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量142

点赞数

文章标签： java

本文链接：https://blog.csdn.net/liuzhou110/article/details/114058360

版权

Java语言
#1语言基础
1.基础语法
(1)基本类型：bete, short, int, long, float, double,char,boolean
(2)引用类型：非基本类型都是引用类型
(3)if语句的使用 1、单分支：if（判断条件）{代码}
2、多分支：if（判断条件）{代码1}else{代码2}
3、嵌套分支：if（判断条件）{if(判断条件){代码}}
（4）for 语句的使用
1，for（开始条件；循环条件；更改条件）{循环体代码}
2，嵌套for循环：根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。

      例子：for（开始条件；循环条件；更改条件）{for（开始条件；循环条件；更改条件）{代码}}

（5）while / do while 语句的使用
1，while(执行条件){代码}
2，do (代码) while（执行条件）
（6）方法的使用
1，形参：变量。实参：方法调用传递的参数。
2，viod关键字有：没有返回值，无，有返回值。
3，方法的重载：
3.1.必须是在同一个类中;
3.2.方法名相同;
3.3.方法参数的个数、顺序或类型不同
3.4.与方法的修饰符或返回值没有关系
2.面向对象
1.封装：
1.1 概念：隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
1.2 优点：提高安全性，提高复用性。
1.3 关键字：权限修饰符，被修饰的只能通过本类对外提供的get ，set进行访问和修改。
2. 继承：
2.1 概念：从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。
2.2 特点：
1. 使用关键字extends关键字，相当于把父类的功能复制了一份。
2.java中继承只能是单继承。但继承可以传递，
3.不能继承父类的私有成员。
2.3 this 与super
概念：this代表本类对象的引用，super代表父类对象的引用
使用：this用来区分局部变量和成员变量
super 用来区分本类变量和父类变量
this和super不可以同时出现在同一个构造方法里
2.4 重写 override
概念：子类继承父类修改父类的原有功能
注意事项：父类的私有方法不能重写，重写时，修饰符要大于等于父类的修饰符。
3. 多态
3.1概念：父类引用指向子类对象
3.2特点：多态的前提：继承和重写
两个口诀：1.概念
2.编译看左边，运行看右边
3.3多态的好处：
1.多态可以让我们不用关心某个对象到底是什么具体类型，就可以使
用该对象的某些方法；
2.提高了程序的宽展性和可维护性

3.接口
概念：全是抽象方法的类
定义： interface接口名{代码…}
特点：1. 通过implements关键字实现接口的功能
2.接口提高了程序的功能扩展，降低了耦合性
3.接口突破了java的单继承的局限性
4.接口和类之间可以多实现，接口和接口之间可以多继承

4.容器
Collection和Map
概念：Collection 一个独立元素的序列，这些元素都服从一条或多条规则
Map 一组成对的”键值对”对象，允许我们使用键来查找值。

1.Collection ：单列集合，用来存放数据结构的。其长度可变，而集合中
可以存放不同类型的对象
1.1List：数据有序，可以重复，可以存null值，可以索引
ArrayList:特点:数据结构是数组，ArrayList是有序集合最后的子类，里面提供了完整的获取，判断，增加，删除，查询，修改等功能。查询速度快，默认是10，扩容是原来的1.5倍。
LinkedList：特点：数据结构是双链表，线程不安全，增删速度快。
Vector：特点：数据结构是数组，线程是安全的增删查询效率都不高。默认是10，扩容是原来的2倍。
1.2Set：数据是无序的，不可以重复
HashSet: 数组结构是哈希表（数组加链表）；HashSetzh只去重
LinkedHashSet:数据结构是哈希表；去重并保留插入顺序。
TreeSet:数据结构是红黑树；去重并排序，需要元素对象实现Comparable接口。
2.Map(双列集合)
HashTable：数据结构是数组+链表；线程安全，修改时会锁住整张表；不可null键 null值；采用链地址法解决哈希冲突。

  HashMap：数据结构是数组+链表；线程不安全；可一个null键多个null值；采用链地址法解决哈希冲突。

  LinkedHashMap：跟HashMap类型，但会维护一个双向链表来保持插入的顺序是有序的。
  TreeMap：数据结构是红黑树；对map的key可以进行排序。

异常：用来封装错误信息的对象。组成结构：类型，提示，行号。
异常的处理方式：捕获或者抛出
5.1 Try{捕获需要的代码
}catch（异常类型异常名）{
处理方案}
5.2 public static void main(String[] args) throws Exception{
} 5.3 常见的异常类型：
5.3.1 Error类代表了编译和系统的错误，不允许捕获；
5.3.2 Exception类代表了标准Java库方法所激发的异常。Exception类还包含运行异常类Runtime_Exception和非运行异常类 Non_RuntimeException这两个直接的子类。
例子：
1. Java.lang.NullPointerException
  　　这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）
2. java.lang.ClassNotFoundException
  　　这个异常是很多原本在JB等开发环境中开发的程序员，把JB下的程序包放在WTk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在JB下做的程序包，一般都是默认加上Package的，所以转到WTK下后要注意把Package的路径加上。

3. java.lang.ArithmeticException
　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。
　　4. java.lang.ArrayIndexOutOfBoundsException
　　这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。
　　5. java.lang.IllegalArgumentException
　　这个异常的解释是"方法的参数错误"，很多J2ME的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
　　6. java.lang.IllegalAccessException
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。
　　
6.泛型（参数化类型）：
在不创建新类型情况下，通过泛型指定不同类型来控制形参具体限制类型
泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。
6.1为什么使用泛型：例子
public class demo {
public static void main(String[] args) {
List arrayList = new ArrayList();//定义一个集合
arrayList.add(“aaaa”);//存放字符串
arrayList.add(100);//存放Integer类型
for(int i = 0; i< arrayList.size();i++){//遍历集合
String item = (String)arrayList.get(i);//强转String
}}}
报错类型：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
/Integer 不能直接强转转成字符串
6.2 泛型的使用：泛型类，泛型接口，泛型方法。
泛型类：
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
泛型接口：
//定义一个泛型接口 public interface Generator
{
public T next();
}
当实现泛型接口的类，未传入泛型实参时：
/**
*未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中

即：class FruitGenerator implements Generator{
如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错：“Unknown class”
*/
class FruitGenerator implements Generator
{
@Override public T next()
{
return null;
}
}
泛型方法：
public class GenericTest
{
//这个类是个泛型类，在上面已经介绍过
public class Generic{
private T key;
public Generic(T key) {
this.key = key;
}

//我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
//所以在这个方法中才可以继续使用 T 这个泛型。
public T getKey(){
return key;
}
/**

这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
public E setKey(E key){
this.key = keu
}
/
}
/*
这才是一个真正的泛型方法。
首先在public与返回值之间的必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
这个T可以出现在这个泛型方法的任意位置.
泛型的数量也可以为任意多个 * 如：public <T,K> K showKeyName(Generic container){
…
}
/
public T showKeyName(Generic container){
System.out.println(“container key :” + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
//这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic这个泛型类做形参而已。 public void showKeyValue1(Generic obj){
Log.d(“泛型测试”,"key value is " + obj.getKey());
}
//这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符? //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj){
Log.d(“泛型测试”,"key value is " + obj.getKey());
}
/*
这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class ‘E’ "
虽然我们声明了,也表明了这是一个可以处理泛型的类型的泛型方法。
但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public T showKeyName(Generic container){ … }
*/

/**

这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class ‘T’ "
对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
所以这也不是一个正确的泛型方法声明。 public void showkey(T genericObj){ }
*/
public static void main(String[] args) {
} }
泛型方法总结：
无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。

7.反射
7.1反射类对象的创建。
Class.forName(“类的全路径=包名.类名”);
类名.class
对象.getClass();
7.2一般反射
7.2.1：常用方法：获得包名、类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名
！！成员变量定义信息
getFields()//获得所有公开的成员变量，包括继承的变量
getDeclaredFields()//获得本类定义的成员变量，包括私有,不包括继承的变量
getField(变量名)
getDeclaredField(变量名)
！！构造方法定义信息
getConstructor(参数类型列表)//获得公开的构造方法
getConstructors()//获得所有公开的构造方法
getDeclaredConstructors()//获得所有构造方法，包括私有
getDeclaredConstructor(int.class, String.class)
方法定义信息
getMethods()//获得所有可见的方法，包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获得本类定义的方法，包括私有,不包括继承的方法
getDeclaredMethod(方法名, int.class, String.class)
反射新建实例
c.newInstance();//执行无参构造
c.newInstance(6, “abc”);//执行有参构造
c.getConstructor(int.class, String.class); //执行含参构造，获取构造方法
反射调用成员变量
c.getDeclaredField(变量名); //获取变量
c.setAccessible(true); //使私有成员允许访问
f.set(实例, 值); //为指定实例的变量赋值，静态变量，第一参数给 null
f.get(实例); //访问指定实例的变量的值，静态变量，第一参数给 null
反射调用成员方法
获取方法
Method m = c.getDeclaredMethod(方法名, 参数类型列表);
m.setAccessible(true) ;//使私有方法允许被调用
m.invoke(实例, 参数数据) ;//让指定的实例来执行该方法
例子： package com.ys.reflex;
public class Person {
//私有属性
private String name = “Tom”;
//公有属性
public int age = 18;
//构造方法
public Person() { }
//私有方法
private void say(){ System.out.println(“private say()…”); }
//公有方法
public void work(){ System.out.println(“public work()…”); }
}
得到 Class 的三种方式：
//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
// 类型的对象，而我不知道你具体是什么类，用这种方法
　　Person p1 = new Person(); 　
　Class c1 = p1.getClass();
//2、直接通过类名.class 的方式得到,该方法最为安全可靠，程序性能更高
// 这说明任何一个类都有一个隐含的静态成员变量 class
　　Class c2 = Person.class;
//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
// 但可能抛出 ClassNotFoundException 异常
　　Class c3 = Class.forName(“com.ys.reflex.Person”);
一个类在 JVM 中只会有一个 Class 实例，.

8.注解

注解有一个标志：@
2.分类
jdk提供好的5个：常用的@Override，标志着该方法是一个重写方法
元注解5个：常用的@Target 和 @Retention
如果这10个不够用还可以自定义注解
3.元注解
– @Target用来描述注解可以出现的位置是哪里，如：在方法上，类
上，属性上…
–值都被维护在ElementType类中。
– @Retention用来描述注解可以存在的生命周期，如：在.java文件
中，在.class文件中，runtime时

4.自定义注解
例子:
//这个类用来测试自定义注解
public class Test1_Annotation {
public static void main(String[] args) {
}
}
//1，创建自定义注解Test：语法：@interface 注解名

	//2、@Target指定注解的位置--ElementType.TYPE是指可以出

现在类上

	//3,@Retention指定注解的生命周期

     --RetentionPolicy.SOURCE是指在源码中有效

	//@Target(  ElementType.METHOD )   
	 @Target({ElementType.TYPE ,ElementType.METHOD } )   

	  @Retention(RetentionPolicy.SOURCE)

	  @interface Test {
		//5、给注解添加属性--注解的语法和java略有不同
		String name()  default "" ;
		String value() default "" ;

//特殊属性，赋值时可以简写
}
//4、使用自定义的注解Test
//6、使用Test注解时，同时给name属性赋值(没有默认值时)
//@Test(name=“hello”)
//7、如果name属性有了默认值，我们使用就可以省略赋值
//@Test(value=“hello”)
@Test(“hello”)
//如果给value属性赋值，可以简写
class Hello {

	//@Test The annotation @Test is disallowed for this location
		String name ;
		@Test
		public void method() {
			System.out.println(123);
		}
	}

springBoot的常用注解。

1.@RestController和@RequestMapping注解
作用：@RequestMapping 注解提供路由信息。它告诉Spring任何来自"/"路径的HTTP请求都应该被映射到 home 方法。
@RestController 注解告诉Spring以字符串的形式渲染结果，并直接返回给调用者。
注： @RestController 和 @RequestMapping 注解是Spring MVC注解（它们不是Spring Boot的特定部分）

2.@PathVaribale 获取url中的数据
例子：@RestController
public class HelloController {

@RequestMapping(value="/hello/{id}",method= RequestMethod.GET)
public String sayHello(@PathVariable(“id”) Integer id){
return “id:”+id;
}
}

@RequestParam 获取请求参数的值

例子：@RestController
public class HelloController {

@RequestMapping(value="/hello",method= RequestMethod.GET)
public String sayHello(@RequestParam(“id”) Integer id){
return “id:”+id;
}
}
注解@RequestParam 和 @PathVarible的区别
@RequestParam是请求中的参数。如get？id=1
@PathVarible是请求路径中的变量如 get/id=1
4. @GetMapping 组合注解是@RequestMapping(method = RequestMethod.GET)的缩写
例子：@RestController
public class HelloController {
//@RequestMapping(value="/hello",method= RequestMethod.GET)
@GetMapping(value = “/hello”)
//required=false 表示url中可以不穿入id参数，此时就使用默认参数
public String sayHello(@RequestParam(value=“id”,required = false,defaultValue = “1”) Integer id){
return “id:”+id;
}
}

9.I/o
9.1 IO的简介：
9.1.1定义：input和output，相对于程序而言是输入与输出
9.1.2分类：1.字符流 2.字节流
字符流：读写文本数据字节流：读写任何数据，主要处理二进制数据。
9.1.3流的概念：流是一组有顺序，有起点和终点的字节集合，本质是数据传输。
流的特征：流只能单向流动，输入流用读取in，输出流用来写出out，数据只能从头读写一次。

9.2 IO应用：
9.2.1：字节流的读取
InputStream抽象类表示字节输入流的所有类的超类和/抽象类
常用方法：
abstract int read()
从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入 byte 数组。
void close()
关闭此输入流并释放与该流关联的所有系统资源。
FileInputStream子类：

FileInputStream(File file)通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String pathname)通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
BufferedInputStream子类
BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8M大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象：
BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
9.2.2：字节流的读取
Reader抽象类：用于读取字符流的抽象类。
常用方法：
int read()
读取单个字符。
int read(char[] cbuf)
将字符读入数组。
abstract int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。
int read(CharBuffer target)
试图将字符读入指定的字符缓冲区。
abstract void close()
关闭该流并释放与之关联的所有资源。

InputStreamReader子类
创建对象
创建使用指定字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)

创建一个使用默认字符集的 InputStreamReader
InputStreamReader(InputStream in)
FileReader子类
创建对象
FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。
FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。

BufferedReader子类
创建对象
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。

例子：public class tt {
public static void main(String[] args) throws Exception {
method1();// 字节读取
method2();//字符读取
}
private static void method2() throws Exception {
//字符流读图片乱码
// BufferedReader in = new BufferedReader(new InputStreamReader
//(new FileInputStream(new File(“D:\teach\1.jpg”))));
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File(“D:\teach\a\1.txt”))));
// System.out.println(in.readLine());
// System.out.println(in.readLine());//null读到/n/r
String line = “”;
while((line = in.readLine())!=null) {//一行一行读
System.out.println(line);
}

   in.close();
}
private static void method1() throws Exception {
   long s = System.currentTimeMillis();
   InputStream in = new FileInputStream("D:\\teach\\1.jpg");
   int b = 0;
   while ((b = in.read()) != -1) {
       // System.out.println(b);
   }
   s = System.currentTimeMillis() - s;
   System.out.println(s + "--");// 7515

   long ss = System.currentTimeMillis();
   InputStream in2 = new BufferedInputStream

(new FileInputStream(“D:\teach\1.jpg”));
int b2 = 0;
while ((b2 = in2.read()) != -1) {
// System.out.println(b2);
}
ss = System.currentTimeMillis() - ss;
System.out.println(ss + “==”);// 32

   in.close();
   in2.close();
}

}

9.2.3：字节流的写出：
OutputStream抽象类表示输出字节流的所有类的超类。
常用方法：
void close()
关闭此输出流并释放与此流有关的所有系统资源。
void flush()
刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void write(int b)
将指定的字节写入此输出流
FileOutputStream子类
创建对象：
创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name)

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file)

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) –追加
BufferedOutputStream子类
该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

创建对象
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out)
9.2.4：字符流的写出：
Writer抽象类是写入字符流的抽象类
常用方法：
void write(char[] cbuf)
写入字符数组。
abstract void write(char[] cbuf, int off, int len)
写入字符数组的某一部分。
void write(int c)
写入单个字符。
void write(String str)
写入字符串。
void write(String str, int off, int len)
写入字符串的某一部分。
abstract void close()
关闭此流，但要先刷新它。

OutputStreamWriter子类
创建对象

创建使用指定字符集的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)

创建使用默认字符编码的 OutputStreamWriter。
OutputStreamWriter(OutputStream out)
FileWriter子类
创建对象

FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构
造 FileWriter 对象。
BufferedWriter子类
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

创建对象
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。
写出例子：
public class rr {
public static void main(String[] args) throws Exception {
// method1();//字节写出
method2();//字符写出
}
private static void method2() throws Exception {
Writer out = new BufferedWriter(new OutputStreamWriter(new
FileOutputStream(new File(“D:\\teach\\a.txt”)) , “utf-8”));

          long s = System.currentTimeMillis();
          for(int i = 48 ; i < 1000000; i++) {
                 out.write(i);
          }
          s = System.currentTimeMillis() - s;
          System.out.println(s + "--");//266
          out.close();
   }
   private static void method1() throws Exception {
          long s = System.currentTimeMillis();
          OutputStream out = new FileOutputStream(new

File(“D:\teach\a.txt”));
for(int i = 48 ; i < 1000000; i++) {
out.write(i);
}
s = System.currentTimeMillis() - s;
System.out.println(s + “–”);//3484
long ss = System.currentTimeMillis();
OutputStream out2 = new BufferedOutputStream(new
FileOutputStream(new File(“D:\teach\a2.txt”)));
for(int i = 48 ; i < 1000000; i++) {
out2.write(i);
}
ss = System.currentTimeMillis() - ss;
System.out.println(ss + “==”);//54
out.close();
out2.close();
}
}

10.其他

1.序列化与反序列化

10.1概述：是将对象的状态信息转换为可以存储或传输的形式的过程。

序列化：利用ObjectOutputStream，对象的信息，按固定格式转成一串字节值输出并持久保存到磁盘化。
反序列化：利用ObjectInputStream，读取磁盘中序列化数据，重新恢复对象。
10.2 特点/应用场景
1、需要序列化的文件必须实现Serializable接口以启用其序列化功能
2、不需要序列化的数据可以被修饰为static的，由于static属于类，不随对象被序列化输出
3、不需要序列化的数据也可以被修饰为transient临时的，只在程序运行期间，在内存中存在不会被序列化持久保存
4、在反序列化时，如果和序列化的版本号不一致时，无法完成反序列化。
5、每个被序列化的文件都有一个唯一id，如果没有添加编译器会根据类的定义信息计算产生一个版本号
6、常用于服务器之间的数据传输，序列化成文件，反序列化读取数据。
7、常用于使用套接字流在主机之间传递对象。

ObjectOutputStream
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。

创建写入指定 OutputStream 的 ObjectOutputStream。
ObjectOutputStream(OutputStream out)

将指定的对象写入 ObjectOutputStream。
void writeObject(Object obj)
ObjectInputStream
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

创建从指定 InputStream 读取的 ObjectInputStream。
ObjectInputStream(InputStream in)

从 ObjectInputStream 读取对象，读取序列化数据。
Object readObject()

2.Object类：所有对象的顶级父类

常用方法：
指示其他某个对象是否与此对象“相等”。
当前对象和参数对象比较大小，默认是比较内存地址，如果要比较对象的属性，可以重写该方法。
boolean equals(Object obj)

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
protected void finalize()

返回该对象的哈希码值。

int hashCode()

返回该对象的字符串表示。
String toString()

3.String类，字符串对象
常用方法
length()：返回字符串的长度。
charAt()：s.charAt(3)返回指定索引处3的 char 值
substring()：截取字符串例子：s.substring(3,7)
equals():判断两个字符串是否相同
split()：根据指定规则切割字符串，例如s2.split(",")
trim() 去除字符串两端的空格

4.时间：LocalDate、LocalTime、LocalDateTime

LocalDate ：日期处理类
常用方法
// 获取当前日期
LocalDate now = LocalDate.now();
// 设置日期
LocalDate localDate = LocalDate.of(2019, 9, 10);
// 获取年
int year = localDate.getYear(); //结果：例子 2019
int year1 = localDate.get(ChronoField.YEAR); //结果：例子2019
// 获取月
Month month = localDate.getMonth(); // 结果：例子SEPTEMBER
int month1 = localDate.get(ChronoField.MONTH_OF_YEAR); //结果：例子9
// 获取日
int day = localDate.getDayOfMonth(); //结果：例子10
int day1 = localDate.get(ChronoField.DAY_OF_MONTH); // 结果：例子10
// 获取星期
DayOfWeek dayOfWeek = localDate.getDayOfWeek(); //结果：例子TUESDAY
int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK); //结果：例子2

LocalTime：时间处理类
// 获取当前时间
LocalTime now = LocalTime.now();
// 设置时间
LocalTime localTime = LocalTime.of(13, 51, 10);
//获取小时
int hour = localTime.getHour(); // 结果：例子13
int hour1 = localTime.get(ChronoField.HOUR_OF_DAY); // 结果：例子13
//获取分
int minute = localTime.getMinute(); // 结果：51
int minute1 = localTime.get(ChronoField.MINUTE_OF_HOUR); // 结果：例子51
//获取秒
int second = localTime.getSecond(); // 结果：10
int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE); // 结果：例子10

LocalDateTime：设置年月日时分秒，相当于LocalDate + LocalTime
// 获取当前日期时间
LocalDateTime localDateTime = LocalDateTime.now();
// 设置日期
LocalDateTime localDateTime1 = LocalDateTime.of(2019, Month.SEPTEMBER, 10, 14, 46, 56);
LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);
LocalDateTime localDateTime3 = localDate.atTime(localTime);
LocalDateTime localDateTime4 = localTime.atDate(localDate);
// 获取LocalDate
LocalDate localDate2 = localDateTime.toLocalDate();
// 获取LocalTime
LocalTime localTime2 = localDateTime.toLocalTime();

5.File：封装一个磁盘路径字符串，对这个路径可以执行一次操作。可以用来封装文件路
径、文件夹路径、不存在的路径。
常用方法：
文件、文件夹属性
length()：文件的字节量
exists()：是否存在，存在返回true
isFile()：是否为文件，是文件返回true
isDirectory()：是否为文件夹，是文件夹返回true
getName()：获取文件/文件夹名
getParent()：获取父文件夹的路径
getAbsolutePath()：获取文件的完整路径
创建、删除
createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs()：新建多层不存在的文件夹\a\b\c
mkdir()：新建单层不存在的文件夹\a
delete()：删除文件，删除空文件夹
文件夹列表
list()：返回String[]，包含文件名
listFiles()：返回File[]，包含文件对象

6.BigDecimal/BigInteger
1.概述
BigDecimal：常用来解决精确的浮点数运算。
BigInteger：常用来解决超大的整数运算。
2.常用方法
add(BigDecimal bd)：做加法运算
substract(BigDecimal bd) ：做减法运算
multiply(BigDecimal bd) ：做乘法运算
divide(BigDecimal bd) ：做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂