1 、基本数据类型
Java内置8种基本类型 -> 6种数字类型 -> 4种整数类型: byte, short, int, long
-> 2种浮点类型: float, double
-> 1种布尔类型: boolean
-> 1种字符类型: char
原始数据类型对应的封装对象
- (byte, Byte), (short, Short), (long, Long), (float,Float), (double, Double), (boolean, Boolean)
- (int, Integer), (char, Character)
2.关键字
- final:
- 修饰变量时，用以定义常量；
- 修饰方法时，方法不能被重写（Override）；
- 修饰类时，类不能被继承。
- short s1=1; s1=s1+1;
这一句编译错误，因为执行s1+1返回的结果是int类型（执行隐式类型转换）。修改的话要强制转换为short型才可以。
3.数组
int[] arr1 = {1,2,3,4}; int[] arr2 = new int[4]; int[] arr3 = new int[]{1,2,3,4};
- 数组越界，抛出ArrayIndexOutOfBoundsException
- 数组具有length属性
- 如果不对数组指定初值，默认初始化为相应数据类型的默认值。
- 多维数组，嵌套中括号即可。
- 数组是一种特殊的结构，在数组对象的对象头中需要记录数组长度的信息
4.String
equals
String str3 =new String("abc");
String str4 =new String("abc");
System.out.println(str3==str4); 返回fl
str3和str4代码分别创建了2个对象，str3和str4指向的是不同的对象，即上面所说的内存空间中存储位置不同。故str3 == str4 返回的肯定是false。(常量池)；
System.out.println(str3.equals(str4)); 返回tr
==比较的是两个对象的引用是否相同，或者是比较原始数据类型是否相等；
- equals()比较的是两个对象的内容是否相同
- StringBuilder线程不安全，但效率高；
- StringBuffer线程安全，但效率低。
equals(一般用来判断是否与某两个变量值相等)
eg:String a="你好"
a.equals("你好")（这里用“==”可能报错为fals,因为储存位置不同）
5.集合
Collection
List(ArrayList)、Set(HashSet)、Queue
Map
map(HashMap)
~类型：List, Set, Map，都是接口而非具体实现
List
- 特点是有序并且按线性方式存储，可以根据元素的下标进行精准的控制。
//List<Integer> a=new ArrayList<Integer>();
//a.add(123);
//s.remove(1);
//a.set(2, 0000);
//a.addAll(a);//增加一个集合
//a.addAll(0, a);//增加集合到某个下标；
求最大最小值
int maxa = Collections.max(list2),mina = Collections.min(list2);
System.out.println("list2's max value is " + maxa);
System.out.println("list2's min value is " + mina);
排序
//由小及大
Collections.sort(list2);System.out.println("list2 sort is "+list2);
//由大及小
Collections.sort(list2,Collections.reverseOrder());//逆序System.out.println("list2 descend sort is "+list2);
//每个元素转换成字符数组
char[] ch = strList.get(i).toCharArray();
//进行比较
ch[j] >= '0'
Set
- 直接继承自Collection接口HashSet内部使用HashSet实现；
- 特点是无序但是不包含重复的元素，可以用来去重
- 元素存放方式为散列存放，即通过计算hash值存放元素。
//Set<String> a =new HashSet<String>;
//a.add("123");
//a.remove("123")因为没有重复值和下标所以直接输入删除数据
Map
- Map单独为一个接口，HashMap是基于哈希表的对Map接口的实现，而哈希表的底层数据结构是数组和链表；
- 特点是能够根据key快速查找value；键必须唯一，put一个键相同的值时该键会被更新，即同一个键只能映射到一个值。
- 键值对以Entry类型的对象实例存在
//Map<String,String > a=new HashSet<String,String>
//a.put("1","2")
//a.remove("1")
//更改就是重新赋值
先用it.hasNext() 判断集合里是不是已经没有元素了
如果有就用
it.next();
就是取得当前集合的元素 然后把指针往后移一位指向下一个元素(java确实还是有指针的只不过你不能自己调用罢了)
6.面向对象
super关键字：既可以作为父类对象的引用调用父类方法，也可以作为父类构造函数名显式调用父类构造函数。
7.抽象类和接口
//一个类可以实现多个接口，但只能继承一个父类
//接口是更高级别的抽象，接口中的方法必须都是抽象方法；接口中声明的方法都是没有方法主体的；
public abstract class fu {
abstract void name();
abstract void xx();
abstract void xiujia();
}父类
public class jc extends fu{
@Override
void name() {
// TODO Auto-generated method stub
System.err.println("xiaonin");
}
@Override
void xx() {
// TODO Auto-generated method stub
System.err.println("123");
}
@Override
void xiujia() {
// TODO Auto-generated method stub
System.err.println("12年");
}
}子类
8.异常处理
常见异常类型：.note
try-catch-finally
可以用多个catch子句处理不同异常，级别由低到高。
try { doSomethint(); } catch (Exception1 e) { doSomethingCatch1(); } catch (Exception2 e) { doSomethingCatch2(); } finally { finallyDoSomething(); }
9.线程
线程是操作系统调度的最小单元，也叫轻量级进程。同一进程可以创建多个线程，而他们都拥有各自的计算器、堆栈和局部变量等属性，并且能够访问共享的内存变量。
线程的5个状态
- 创建（New）：使用new关键字创建一个线程
- 就绪（Ready）：调用start方法，等待CPU调度
- 运行（Running）：执行run方法
- 阻塞（Blocked）：由于一些原因放弃CPU使用权，暂时停止执行
- 死亡（Dead）：run方法执行完毕或者执行时产生异常
volatile和synchronized
Java中提供了关键字volatile和synchronized关键字来保证线程之间操作的有序性。volatile包含了禁止指令重排序的语义，并保证不同线程对同一变量操作时的可见性；synchronized关键字对同一时刻同一变量只允许一个线程对其进行lock操作。
线程创建
继承Thread类重写run()方法
匿名内部类，即在new Thread()后跟具体的定义体，其中重写了run()方法
实现Runnable接口，重写run()方法
开启线程的run()和start()方法区别
run()方法不能新建一个线程，而是在当前线程中调用run()方法；
start()方法新建一个线程并调用其run()方法。
终止线程不要使用stop()
public class xc01 extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
public class xc02 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+i); //Thread.currentThread().getName()+i 获取线程name
}
}}
public class test {
public static void main(String[] args) {
xc01 xc01=new xc01();
xc02 xc02=new xc02();
Thread th=new Thread(xc02);
th.start();
for (int i = 0; i <5; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
xc01.start();
}
}
多线程
public class sp implements Runnable {
static int a=100;
@Override
public void run() {
while (true) {
synchronized (this) {
if (a>0) { System.err.println(Thread.currentThread().getName()+"第"+a+"号");
a--;
}else {
break; }
}
}
}
}
public class day0701 {
public static void main(String[] args) {
sp sp=new sp();
Thread a1 =new Thread(sp);
Thread a2 =new Thread(sp);
Thread a3 =new Thread(sp);
Thread a4 =new Thread(sp);
a1.setName("窗口1");
a2.setName("窗口2");
a3.setName("窗口3");
a4.setName("窗口4");
a1.start();
a2.start();
a3.start();
a4.start();}
}
10.I/O操作
流是一组有顺序的， 有起点和终点的字节集合，是对数据传输的总称或抽象。
I/O流的分类
- 根据处理数据类型划分为：字符流和字节流
- 根据数据流向划分为：输入流和输出流
字符流和字节流
字符流本质上就是基于字节流，读取时查询相应的码表。
区别：
- 读写单位：字节流以字节为单位；字符流以字符为单位，一次可能读多个字节；
- 处理对象：字节流能处理所有类型的数据（图片、视频等），而字符流只能处理字符类型的数据。
字节流(简单来说可以完整复制歌曲)
FileInputStream（BufferedInputStream）
FileOutputStream（BufferedOutputStream）
FileInputStream fis=new FileInputStream("C:\\Users\\86185\\Desktop\\a.mp3");
FileOutputStream fos=new FileOutputStream("b.mp3");
byte q[]=new byte[1024];
int len=0;
BufferedInputStream bis =new BufferedInputStream(new FileInputStream("C:\\Users\\86185\\Desktop\\a.mp3"));
FileOutputStream bos=new BufferedOutputStream(new FileOutputStream("s.mp3"));
byte q[]=new byte[1024];
int len=0;
字符流（简单来说可以复制字符串）
FileReader(BufferedReader)
FileWriter(BufferedWrite)
FileReader fr=new FileReader("C:/Users/86185/Desktop/屏幕共享 2/00.txt");
FileWriter fw=new FileWriter("2.txt");
int len=0;
char b[]=new char[1024];
FileReader br=new BufferedReader(new FileReader("C:/Users/86185/Desktop/屏幕共享 2/00.txt"));
FileWriter bw=new BufferedWriter(new FileWriter("9.txt"));
int len=0;
char b[]=new char[1024];
eg:
public static void main(String[] args) {
FileReader fr=null;
FileWriter fw=null;
try {
fr=new FileReader("C:/Users/86185/Desktop/屏幕共享 2/00.txt");
fw=new FileWriter("2.txt");
int len=0;
char b[]=new char[1024];
while ((len=fr.read(b))!=-1) {(如果fr.read()读到了文件最后，会返回一个-1，就表示读到了文件最后了)
fw.write(b, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
finally{
if (fw!=null) {
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (fr!=null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
人生永远无法回头，就连这平淡不惊的一幕，终有一日也会碎落满地
