Java知识整理
- 概念问题
- 面向对象和面向过程
- Java和C++
- Java 语言特点
- JDK 和 JRE和JVM
- Oracle JDK 和 OpenJDK
- 字符型常量和字符串常量
- 构造器 Constructor 是否可被 override
- override重写和overload重载
- 面向对象三大特性: 封装 继承 多态
- String 、 StringBuffer 和 StringBuilder
- 自动装箱与拆箱
- 定义一个不做事且没有参数的构造方法的作用
- java和javax:javax包成为标准一部分
- 接口和抽象类
- 基本与包装类型使用标准
- 自动装箱
- equlas注意事项
- 成员变量与局部变量
- == 与 equals
- hashCode 与 equals
- 线程、程序、进程
- 线程基本状态
- final关键字
- 异常处理
- Throwable类常用方法
- 字段不希望序列化
- 获取用键盘输入
- 内部类
- staic
- I/O流
- BIO、NIO、AIO
- 浅拷贝和深拷贝
- Collection
- Arrays操作
- BigDecimal的用处
- Arrays.asList使用
- 正确将数组转化为ArrayList
- Collection.toArray转为数组
- 泛型限定
- 泛型数组(重点)
- 可重入/不可重入锁
- 乐观锁、悲观锁
概念问题
面向对象和面向过程
Java和C++
Java 语言特点
JDK 和 JRE和JVM
Oracle JDK 和 OpenJDK
字符型常量和字符串常量
构造器 Constructor 是否可被 override
override重写和overload重载
面向对象三大特性: 封装 继承 多态
String 、 StringBuffer 和 StringBuilder
自动装箱与拆箱
定义一个不做事且没有参数的构造方法的作用
java和javax:javax包成为标准一部分
接口和抽象类
- 方法:接口默认public,不可实现;抽象类可有非抽象方法
- 变量:接口只能有static和final
- 一个类可多接口,单抽象类
- 理念:抽象类是模板;接口是行为抽象。
public interface DoSomething {
static String name="null";
final String type="animal type";
String getAnimalName();
}
public interface EatSomething {
String eat();
}
public abstract class Animal {
abstract public String getName();
public String getType(){
return "not a human";
}
}
public class Dog extends Animal implements DoSomething,EatSomething {
@Override
public String getName() {
return null;
}
@Override
public String getAnimalName() {
return null;
}
@Override
public String eat() {
return null;
}
}
JDK8中,接口可定义静态方法。
public interface EatSomething {
String eat();
static String getPlaceName() {
return "house";
}
}
基本与包装类型使用标准
- POJO类必须使用包装数据类型。
- RPC方法返回值和参数必须使用包装类型。
- 局部变量使用基本数据类型。
NPE问题:Null Pointer Exception空指针例外。Integer的null和0表示不同意思,而int没有null,就无法区分意思。
自动装箱
自动装箱创建Integer对象,数值在-128~127,将创建的Integer缓存起来,下次再出现该数值,直接从缓存去对象。
(IDEA阿里巴巴的p3c插件会检测==错误)。
int x=3;
int y=3;
System.out.println("x==y:"+(x==y));
Integer x1=new Integer(3);
Integer y1=new Integer(3);
System.out.println("x1==y1:"+(x1==y1));
System.out.println("x1.equals(y1):"+(x1.equals(y1)));
上面x和y引用的是相同的对象。
equlas注意事项
jdk7引入Objects.equals(…,…)更好地避免equals调用出错。
成员变量与局部变量
== 与 equals
public class Test {
public static void main(String[] args) {
String s = new String("nihao");
String s1 = new String("nihao");
System.out.println("s==s1:"+(s==s1));
System.out.println("s.equals(s1):"+(s.equals(s1)));
}
}
结果:
特殊情况:常量池的作用
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
String aa="ab";
String bb="ab";
System.out.println("aa==bb:"+(aa==bb));
System.out.println("aa.equals(bb):"+(aa.equals(bb)));
结果:
hashCode 与 equals
String s = new String("nihao");
String s1=new String("nihao");
System.out.println("s:"+s);
System.out.println("s1:"+s1);
System.out.println("s.equals(s1):"+(s.equals(s1)));
System.out.println("s.hashcode:"+s.hashCode());
System.out.println("s1.hashcode:"+s1.hashCode());
结果:
重点注意: equals 方法被覆盖过,则 hashCode 方法也必须被覆盖。
如果hashcode相同,则比较equals。
线程、程序、进程
线程基本状态
final关键字
- 变量
- 方法(方法锁定,以防任何继承类修改它的含义;第二个原因是效率)。
- 类(类不能被继承)
异常处理
- Error(错误):是程序无法处理的错误。
- Exception(异常):是程序本身可以处理的异。
- 注意:异常和错误的区别:异常能被程序本身处理,错误是无法处理。
Throwable类常用方法
public class MyThrowable extends Throwable {
//返回异常发生时的简要描述
@Override
public String getMessage() {
return "wait,这里可能出现了问题";
}
//返回异常发生时的详细信息
@Override
public String toString() {
return "我的异常类";
}
//返回异常对象的本地化信息。
// 使用Throwable的子类覆盖这个方法,可以生成本地化信息。
// 如果子类没有覆盖该方法,则该方法返回的信息与getMessage()
// 返回的结果相同
@Override
public String getLocalizedMessage() {
return this.getMessage();
}
//在控制台上打印Throwable对象封装的异常信息
@Override
public void printStackTrace() {
super.printStackTrace();
}
}
public static void main(String[] args) {
try{
throw new MyThrowable();
}catch (MyThrowable myThrowable){
myThrowable.printStackTrace();
System.out.println("-----------------------");
System.out.println(myThrowable.getMessage());
System.out.println(myThrowable.toString());
}
}
结果:
- try:其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。
- catch:用于处理try捕获到的异常
- finally:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return 语句时,finally语句块将在方法返回之前被执行。
catch (MyThrowable myThrowable){
....
return;
}
finally {
System.out.println("你必须执行我finally不可");
}
结果为:
字段不希望序列化
transient关键字,阻止实例中那些用此关键字修饰的的变量序列化;
获取用键盘输入
两种方式
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
System.out.println(s);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s1 = reader.readLine();
System.out.println(s1);
内部类
- 成员内部类
//静态内部类
Circle.Draw draw = new Circle.Draw();
//非静态内部类
Circle circle = new Circle(1);
Circle.Made made = circle.new Made();
- 局部内部类
- 静态内部类
- 匿名内部类
scan_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
}});
history_bt.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {}});
与以上匿名内部类相同的作用代码为:
private void setListener()
{
scan_bt.setOnClickListener(new Listener1());
history_bt.setOnClickListener(new Listener2());
}
class Listener1 implements View.OnClickListener{
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}
class Listener2 implements View.OnClickListener{
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
}
staic
- 变量、方法
- 静态代码块:静态代码块—>非静态代码块—>构造方法。
- 静态内部类
- 静态导包(1.5新特性)
静态代码块和非静态代码块
public class Dog {
{
System.out.println("这里是非静态代码块");
}
static {
System.out.println("这里是静态代码块");
}
public Dog(){
System.out.println("这里是构造函数");
}
}
结果为:
I/O流
基类:
InputStream/Reader: 所有的输入流的基类
OutputStream/Writer: 所有输出流的基类
BIO、NIO、AIO
- BIO: 阻塞IO
- NIO: 同步非阻塞IO
- AIO: 异步非阻塞的IO
浅拷贝和深拷贝
Collection
- 排序
- 查找、替换
- 同步控制(可以用JUC包并发集合替代)
排序操作
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println("开始序列:"+list);
Collections.reverse(list);
System.out.println("翻转后:"+list);
Collections.shuffle(list);
System.out.println("随机后:"+list);
Collections.sort(list);
System.out.println("排序后:"+list);
Collections.swap(list,0,3);
System.out.println("交换第1和3个后:"+list);
//定制sort
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return -o1.compareTo(o2);
}
});
System.out.println("定制sort后:"+list);
}
查找、替换
System.out.println(list+" 二分查找3:"+Collections.binarySearch(list,3));
System.out.println("最大元素:"+Collections.max(list));
System.out.println("3出现次数:"+Collections.frequency(list,3));
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(3);
list1.add(2);
System.out.println("3,2出现在哪里:"+Collections.indexOfSubList(list,list1));
结果为:
Arrays操作
int arr[]={5,4,3,2,1};
Arrays.sort(arr,1,3);
System.out.println("arr排序1到3:"+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("arr排序后:"+Arrays.toString(arr));
System.out.println(Arrays.toString(arr));
System.out.println("4在位置:"+Arrays.binarySearch(arr,4));
结果为:
剩下还有:
- 比较 equals
- 填充 fill
- 转列表 asList
- 转字符串 toString
- 复制 copyOf
BigDecimal的用处
浮点数之间等值判断不能使用==来比较,包装数据类型不能用equals来比较。
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
System.out.println("两结果之间进行对比:"+x.equals(y));
//保留几位小数n
BigDecimal m = new BigDecimal("1.2223456");
BigDecimal n = m.setScale(3, BigDecimal.ROUND_HALF_DOWN);
System.out.println(m+"保留三位:"+n);
结果显示为:
Arrays.asList使用
注意必须传入对象数组,基本类型不可以。
且底层就是数组。
最重要的是,Arrays.asList() 方法返回的并不是 java.util.ArrayList ,而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。
Integer arrls[]={8,7,6,5};
List<Integer> list = Arrays.asList(arrls);
System.out.println("使用asList后:"+list.toString());
正确将数组转化为ArrayList
简单方法
new ArrayList<>(Arrays.asList(“a”, “b”, “c”))
java8的steam
不要在 foreach 循环里进行元素的 remove/add 操作
可以用迭代器的remove方法,否则抛出异常。
fail-fast机制: :多线程操作集合,一线程访问集合,但检测到集合被其他线程修改,便会出现情况。java.util包下面的所有的集合类都是fail-fast的,而java.util.concurrent包下面的所有的类都是fail-safe的。
Collection.toArray转为数组
list.toArray(new String[0])
这里只为指定返回的数组的类型。0是为节省空间。
泛型限定
public static <T extends Comparable<? super T>> T Min(T[] nums){
T val=nums[0];
for(int i=1;i<nums.length;i++){
if(val.compareTo(nums[i])>0){
val=nums[i];
}
}
return val;
}
其中T extends Number表明上限是Number,也就是T必须是Number的子类。? super T 表明下限是T。
例如Integer是这样定义的:
public final class Integer extends Number implements Comparable<Integer>
- T表示泛型
- ? 表示不确定的类型,一般用在通配
- Object表示java中所有类的父类,在集合中使用时要格外注意。
- jdk为了便于理解,用K表示键,V表示值,T表示type类型,E表示enum枚举,其实这四个都只是符号,都是表示泛型名称。换成其他字母都没关系,但是都要在之前声明。
泛型数组(重点)
可重入/不可重入锁
- 不可重入:线程获取锁,再次获取锁时,就会被阻塞。
- 可重入: 线程可以进入已经拥有锁的同步代码块。
isLocked | false |
lockedBy | null |
lockedCount | 0 |
进入lock():
thread为当前线程。
由于while(isLocked && lockedBy != thread),而isLocked为false,所以不执行while内的wait,而是
isLocked | true |
lockedBy | 当前线程 |
lockedCount | 1 |
接着这个线程再次申请这个锁,由于满足lockedBy与当前线程匹配,所以仍不能执行while,而是
isLocked | true |
lockedBy | 当前线程 |
lockedCount | 2 |
如果此时有其它线程执行lock(),那么就会满足while的条件,而执行wait(),挂起等待。
总结:如此便实现了一个线程可以重入一个锁。
乐观锁、悲观锁
- synchronized是悲观锁,这种线程一旦得到锁,其他需要锁的线程就挂起。
- CAS是乐观锁,每次不加锁,有冲突就重试。
CAS( Compare And Swap )比较并替换。