JAVA学习笔记

1.break/continue配合标签使用

bye:
			for(int i=0;i<=10;i++)
			{
				for(int j=0;j<=10;j++)
				{
					System.out.println(i+" "+j);
					if(j==10)
						break bye;
				}
			}

在这个代码片中当j=10时，break将会直接跳出最外层的循环，也就是整个bye标签之外。

2.数组的初始化
int型数组初始化为0
boolean型数组初始化为false
对象类型数组初始化为空

String name[]=new String[10];
String[i]=NULL;

注意NULL和空串并不等价。

3.数组的拷贝

int []num = Arrays.copyOf(key,key.length);

这句话将key数组的值从0到key.length-1复制到了num数组中。
注意第二个参数，这是指复制的长度，长度超过key.length则补零替代。

4.不规则数组的定义

int num[][] = new int [10][];
for(int i=0;i<9;i++)
	num[i] = new int[i+1];

5.final 字段
final字段必须在构造对象时初始化，之后便不允许修改。
构造对象时初试化并不代表着一定要在构造函数里初试化，以下两种初始化方法都是可行的。

public final int seven = 7;

Test(int s)
{
	seven=s;
}

6.static变量
静态变量不被某个对象所持有，而是整个类持有，所以在某个类中static变量有所改变，那么同一个对象的其他类中也会有相同的改变.

7.JAVA没有引用传递，只有值传递。

8.方法中的局部变量必须被初始化，而类中的成员变量可以不进行初始化，这样系统会自动为其初始化。

9.局部变量遮蔽问题

public class Test {
	public  int seven = 7;
	Test(int s)
	{
		 int seven=s;
	}
}

注意Test()构造函数中存在一个int seven，这时候这个整型变量seven就会遮蔽住成员变量seven，这是若调用Test test = new Test(6);，那么test对象中的seven值依然为7，这就是遮蔽现象。

为了解决这种问题可以在构造函数seven前加一个this，这样seven指的就是Test变量的seven变量了。

public  int seven = 7;
	Test(int s)
	{
		 this.seven=s;
	}

10.静态导包

import static java.lang.System.*;
import static java.lang.Math.*;

out.println((int)pow(2,7));//yes!

12.子类的引用可以指向父类变量，但是父类变量依然无法调用子类中的方法。

Test t = new Test();
child_Test ct = new child_Test();
ct.child_method();
t = ct;//yes！
t.child_method();//error!

如图，child_Test是Test类的子类，父类变量t可以指向子类的引用ct，但是t依然无法调用子类中的方法child_method。

13.final类不允许继承，且将类置为final时，其中所有的方法都会变成final方法，但其中的成员变量不会。

14.关于父类强制类型的转换。
第一种不能转换的情况

Test t = new Test();
child_Test ct=(child_Test)t;//会出现ClassCastException异常，一个完全的父类不能强制转换为儿子

第二种可以转换的情况

Test t = new child_Test();
child_Test ct=(child_Test)t;//yes！t本质上还是一个子类变量，可以强制转为儿子

15.Abstract类不能实例化对象，但可以创建一个具体子类的对象。
这点和Interface相同

16.Protected允许本包其他类可见。注意其他包的类无法访问，其他包中的子类也无法访问。

17.参数数量可变的函数

 public static double max(double...val)//关键在于这三个点
    {
    	double large = Double.NEGATIVE_INFINITY;
    	for(double v:val)
    	{
    		if(v>large)
    			large = v;
    	}
    	return large;
    }
System.out.print(max(0.1,4.7,8.9,-12.5));//max中想传多少个数字都没问题

18.java中对对象类型的数组的排序必须实现Comparable接口中的CompareTo方法。

public class Test implements Comparable<Test>{
	public int key;
	Test(int key)
	{
		this.key = key;
	}
	
	public int compareTo(Test t)
	{
		return Integer.compare(t.key, key);
	}
}

注意是必须实现接口类中的方法，不能自己再去写一个CompareTo方法。

19.java自定义排序的两种方式
① 待排序的对象是实现了Comparable接口的类的实例

public class Test implements Comparable<Test>{
	public int key;
	Test(int key)
	{
		this.key = key;
	}
	
	public int compareTo(Test t)
	{
		return Integer.compare(t.key, key);
	}
}

② 比较器方式，比较器是一个实现了Comparator类的实例。

public class Test implements Comparator<String>{
	@Override
	public int compare(String arg0, String arg1) {
		// TODO Auto-generated method stub
		return arg0.length()-arg1.length();
	}
}

注意Test只是一个比较器，而不是第一种方法中包含待排对象的类。
调用时要把Test比较器传入sort函数。

public static void main(String args[]) {
		// TODO Auto-generated method stub
		String[] str = {"abc","bd","z"};
		Arrays.sort(str,new Test());
		for(int i=0;i<3;i++)
			System.out.println(str[i]);
	}

20.关于集合的遍历器
不能在调用next()方法之前调用remove()方法，否则会出现IllegalStateException异常，每次remove的元素是上次next方法得到的元素。

        Queue q = new LinkedList<Integer>();
		q.add(1);
		q.add(2);
		Iterator<Integer>it = q.iterator();
		while(it.hasNext())
		{
			it.remove();//Wrong!!
			int n = it.next();
			//it.remove();
			System.out.println(n);
		}

21.ListIterator类的listlterator方法返回了一个迭代器对象，这个迭代器可以和普通的iterator迭代器一样遍历linklist，并且还有add函数，可以在当前迭代器之前插入元素，利用这一点可以不停向linklist头部插入元素。

        LinkedList<Integer> l = new LinkedList<Integer>();
	    l.add(1);
	    l.add(2);
	    l.add(3);
	    ListIterator<Integer>iterator = l.listIterator();
	    iterator.add(10);
	    iterator = l.listIterator();
	    while(iterator.hasNext())
       {
    	   int x = iterator.next();
    	   System.out.println(x);
       }

22.优先队列的自定义排序

要写一个实现了Comparator接口的类，通过这个类中的compare方法控制优先队列。

public class Test implements Comparator<String>{
	@Override
	public int compare(String arg0, String arg1) {
		// TODO Auto-generated method stub
		return arg0.length()-arg1.length();//长度短的字符串在前面
	}
}

将这个Test类的对象放到priorityqueue中的构造函数中。

        Test test  = new Test();
		var queue = new PriorityQueue<String>(test);
		queue.add("dog");
		queue.add("zysdasfsdff");
		queue.add("is");
		while(queue.isEmpty()==false)
		{
			System.out.println(queue.poll());//poll()取头部并退队一个元素，等于peek()+remove().
		}

23.注意hashmap中的getOrdefault方法，用这个函数可以控制map中返回的初始值。

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		var map = new HashMap<String,String>();
		map.put("zyf", "girl");
		System.out.println(map.getOrDefault("fql", "boy"));
	}