JAVA基础核心，早年的总结，今天分享

获取时间：System.currnetTimeMillis();

系统默认不带缀的浮点数为double型，如5.1为double型，而float a=5.1是会报错的

‘\r‘表示 接受键盘的输入，相当于按下了回车键；相当于搜狗输入法按了空格键
‘\n‘是换行

byte b=2;b=b-1;这是错误的，因为表达式b-1在进行运算时，系统会自动把b的值提升为int型再和1相减，结果就是一个int型。

System.out.println(‘a’+1)   //输出98
System.out.println(“”+‘a’+1)   //输出a1

简单总结就是：成员函数，在多态调用时，编译看左边，运行看右边

Object类-equals()   实际是比较的对象引用的地址

当内部类中定义了静态成员，该内部类必须是static
(2)、当外部类中的静态方法，访问内部类时，内部类也必须是 static

匿名颞部类中定义的方法最好不要超过3个

System.exit(0); 系统退出，jvm结束

每一个安卓程序对应一个 dex

主意
(1)、主意：finally中定义的通常是 关闭资源代码，因为资源必须释放
(2)、finally只有一种情况不会执行，当执行到 System.exit(0);

创建线程-run和start特点
1、为什么要覆盖 run 方法呢，thread 类用于描述线程
(1)、该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是 run 方法
(2)、也就是说 Thread 类中的 run 方法，用于存储线程要运行的代码

/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket extends Thread{
private static int tick = 100;
public void run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+" sale："+tick--);
}
}
}
}
public class Demo{
public static void main(String[] args){
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
Ticket t4 = new Ticket();
t1.start();
t2.start();                         //这里的start调用的就是上面的run方法
t3.start();
t4.start();
}
}

实现线程的两种方式
继承类 Thread

实现runnable接口

两种方式区别：
[1]、继承 Thread：线程代码存放在 Thread 子类 run 方法中     new 本类，然后直接执行start方法
[2]、实现 Runnable：线程代码存放在接口的子类的 run 方法中   new thread类  然后执行start方法

java对于多线程的安全，提供了专业解决方式：
(1)、就是同步代码块
(2)、synchronized(){}

ublic void run(){
while(true){
synchronized(obj){
if(tick>0){
System.out.println(Thread.currentThread().getName()+" sale："+tick--);

class Bank{
private int sum;
Object obj = new Object();
public synchronized void add(int n){
sum = sum + n;
System.out.println("sunm = "+sum);
}

/*
需求：银行有一个金库
有两个储户分别存300元，每次存100，存3次
目的：改程序，是否有安全问题

如何找问题：
1、明确哪些代码是多线程运行代码
2、明确共享数据
3、明确多线程运行代码中哪些语句是操作共享数据的
*/
class Bank{
private int sum;
Object obj = new Object();
public synchronized void add(int n){      // 加锁的时候就是在存入钱的时候加上锁就行了
sum = sum + n;
System.out.println("sunm = "+sum);
}
}
class Cus implements Runnable{
private Bank b = new Bank();
public void run(){
for(int x=0;x<3;x++){
b.add(100);
}
}
}
public class Demo{
public static void main(String[] args){
Cus c = new Cus();
Thread c0 = new Thread(c);
Thread c1 = new Thread(c);
c0.start();
c1.start();
}
}

public class Demo{
public static void main(String[] args){
String s1 = "abc";//s1是一个类类型变量，“abc”是一个对象。字符串最大特点：一旦被初始化，就不可以被改变
s1 = "kk";//字符串 abc 未改变，改变的是 s1的指向
String s2 = new String("abc");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
/*String类，复写了Object类中equals方法，该方法用于判断字符串是否相同
s1代表一个对象
s2代表两个对象
*/
}
}

根据位置获取位置上的某个字符
int indexOf(int ch)：返回的是ch字符第一次出现的位置
int indexOf(int ch,int fromIndex)：从fromIndex指定位置开始，获取str在字符串中的出现的位置
int indexOf(String str)：返回的是字符串在总字符串中第一次出现的位置
int indexOf(String str,int fromIndex)：从fromIndex指定位置开始，获取str在字符串中的出现的位置

判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase(str);

替换
String replace(char oldChar,char newChar)

切割
String[] split(String str)

String substring(int beginIndex, int endIndex) //包含头，不包含尾部 返回新字符串，是大字符串的子字符串

将字符串转成大写或者小写
(1)、String toUpperCase();
(2)、String toLowerCase();     trim（）对两个字符串进行自然顺序的比较
(1)、int compareTo(String);

StringBuffer(常见功能-添加)
(1)、字符串的组成原理就是通过该类实现的。
(2)、StringBuffer可以对字符串内容进行增删
(3)、StringBuffer是一个容器
(4)、很多方法与String相同
(5)、StringBuffer是可变长度的

存储
StringBuffer append()：将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(index,数据)：可以将数据插入到指定位置上去
(2)、删除
StringBuffer delete(start,end)：删除缓冲区中的数据，包含start，不包含end
StringBuffer deleteCharAt(index)：删除指定位置的字符
sb.delete(0,sb.length());  清空缓冲区，删除全部
sb.delete(2,3);  删除一个字符，应该用 sb.deleteCharAt(2);
(3)、获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start,int end)  注意，返回的是string，不是StringBuffer
(4)、修改
StringBuffer replace(start,end,string);
StringBuffer reverse()
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。

StringBuffer 是线程同步  多线程也可以，自身有判断锁，但是效率低
(2)、StringBuilder 是线程不同步  不是多线程的，不用判断锁，所以单线程都用这个

fw.flush();
//关闭刘子源，但是关闭之前会刷新一次内部的缓冲的数据。，将数据刷到目的地中，和flush区别，flush(),刷新后，流可以继续使用，close刷新后，会将流关闭。
//操作完，必须关闭
fw.close();

FileWriter fw = null;
try{
//为true表示不覆盖已有文件，并且续写
fw = new FileWriter("Demo.txt",true);

import java.io.*;
class Demo{
public static void main(String args[]) throws Exception{           // io流 读取后写入的方式

字符流的缓冲区

1、缓冲区的出现提高了对数据的读写效率
2、对应类
(1)、BufferdWriter
(2)、BufferdReader
3、缓冲区要结合流才可以使用
4、在流的基础上对流的功能进行了增强
5、
void close()  关闭此流，但要先刷新它。
void flush() 刷新该流的缓冲
void newLine() 写入一个行分隔符。 跨平台

FileReader fr = new FileReader("Demo.txt"); //定义一个字符串数组，用于存储到的字符 //该 read(char[])返回的是读到的字符个数 char[] buf = new char[1024]; int num = 0; while((num = fr.read(buf))!=-1){ System.out.println(num+"..."+new String(buf,0,num)); // 注意这里最后的打印方式 } }

while((line = bufr.readLine())!=null){
bufw.write(line);
bufw.flush();
bufw.newLine();//必须写

O流(readLine的原理图例)
readLine()方法原理
不论是读一行，获取多个字符，其实最终都是在硬盘上一个一个读取，所以最终使用的还是 read() 方法一次读一个的方法

都是一个一个读取的所以，读取的时候读一个执行一次，不如读1024个在执行一次

IO流(MyBufferedReader)
明白了 BufferedRead 类中特有方法 readLine 的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法
来模拟一下BufferedReadLine
[java] view plaincopy
/*
通过缓冲区复制一个 .java 文件
*/
import java.io.*;
class Demo{
public static void main(String args[]) throws IOException{
FileReader fr = new FileReader("Demo.java");
MyBufferedReader myBuf = new MyBufferedReader(fr);
String line = null;
while((line=myBuf.myReadLine())!=null){
System.out.println(line);
}
myBuf.myClose();
}
}
class MyBufferedReader{
private FileReader fr;
MyBufferedReader(FileReader fr){
this.fr = fr;
}
//可以一次读一行数据的方法
public String myReadLine() throws IOException{
//定义一个临时容器，原BufferedReader封装的是字符数组
//为了方便，定义一个StringBuilder容器，因为最终还是要将数据变成字符串
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=fr.read())!=-1){
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
//防止最后一行没有换行的情况
if(sb.length()!=0){
return sb.toString();
}else{
return null;
}
}
public void myClose() throws IOException{
fr.close();
}
}

六、IO流(装饰设计模式)
1、当想要对已有对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能，那么该自定义类称为装饰类
2、装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的功能，提供更强的功能。

七、IO流(装饰和继承的区别)
八、IO流(自定义装饰类)
九、IO流(LineNumberReader)
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
[java] view plaincopy
import java.io.*;
class Demo{
public static void main(String args[]) throws IOException{  /**
* 非常简便的加行标类
*
* @author GreaterMan
*
*/
public class MoreIo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("D:\\text\\Example05.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null;
lnr.setLineNumber(0);
while ((line = lnr.readLine()) != null)
{
System.out.println(lnr.getLineNumber() + ":" + line); //自动换行，而且自增行数
}
lnr.close();
}

}

FileReader fr = new FileReader("Demo.java"); LineNumberReader lnr = new LineNumberReader(fr); String line = null; lnr.setLineNumber(2); while((line=lnr.readLine())!=null){ System.out.println(lnr.getLineNumber()+":"+line); } lnr.close(); } }

需求：想要操作图片数据。据悉要到字节流

inputStream outputStream

FileReader fr = new FileReader("Demo.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null; lnr.setLineNumber(2);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close();
}
}

需求：想要操作图片数据。据悉要到字节流
inputStream outputStream
/*
需求，通过键盘录入数据。  									高效率的输入输出流操作
OutputStream out = System.out;

OutputStream out = System.out;

当录入一行数据后，就将改行数据进行打印，如果录入数据是over，那么停止录入 */
import java.io.*;
public class Demo{
public static void main(String args[]) throws IOException{//获取键盘录入对象
InputStream in = System.in; //将字节流对象转换成字符流对象，使用转换流，
InputStreamReader InputStreamReader isr = new InputStreamReader(in); //为了提高效率，将字符进行缓冲区技术高效操作，使用bufferedReader
BufferedReader bufr = new BufferedReader(isr);
String line = null;
while((line = bufr.readLine())!=null)
{
if(line.equals("over"))
{
break;
}
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
//BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));              对应键盘      FileOutputStream

//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));                          对应硬盘

BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"))                           file针对的是文件

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));  对应编码  字符流里面用字节流
目的：OutputStream Writer
是否是纯文本？是，Writer                                                         对应编码
是不是设备？是，硬盘，使用，FileWriter                                           FileOutputStream 可指定文件编码

但是存储是，需要加入指定的编码表，而制定的编码表，只有转换流可以指定。
所以要使用的对象是 OutputStreamWriter.
而该转换流对象要接收一个字节输出流。而且还可以操作文件的字节输出流，FileOutputStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要高效吗？需要
BufferedWriter bufw = new BufferedWriter(osw);

File.separator 转义字符"\"

File类的操作

创建
boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false
和输出流不一样棒，输出流对象一建立就创建文件，而且文件已经存在，会覆盖
boolean mkdir() 创建此抽象路径名指定的目录。
2、删除
boolean delete() 删除此抽象路径名表示的文件或目录。
void deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
当被操作时候，删除不了，所以等虚拟机终止时，删除