Java笔记记录

把以前看的内容笔记补起来，保存哈在《Java编程思想》这本书中自己需要了解到的一些问题；从2020这一年开始到现在感觉自己都没有什么长进，无论是算法还是Java或者c；不想颓废，大一上的目标并未实现并且有点惨兮兮，所以现在开始需要好好调整哈了，每天坚持学Java。

一.操作符

1.更简单的打印语句

在一般都是采用

System.out.println(.....);

在这里引入一个静态导入（static import），创建一个小类库来简化打印语句的编写:

import java.util.*;
import static net.mindview.util.Print.*;
.....
print(...);

2.对象当中的“赋值”

对一个对象操作时，实际上就是对对象的引用，所以倘若“将一个对象赋值给另一个对象”，实际上是将“引用”从一个地方复制到另一个地方；

class Tank{
	int level;
}

Tank t1=new Tank();
		Tank t2=new Tank();
		t1.level=9;
		t2.level=47;
		System.out.println("1:t1.level: "+t1.level+" t2.level "+t2.level);
		t1=t2;//t1.level=t2.level;（后者主要避免别名）
		System.out.println("1:t1.level: "+t1.level+" t2.level "+t2.level);
		t2=t1;
		System.out.println("1:t1.level :"+t1.level+" t2.level "+t2.level);

输出：

1:t1.level: 9 t2.level 47
2:t1.level: 47 t2.level 47
3:t1.level :47 t2.level 47

(2).方法调用当中的别名：

class letter{
	float a;
}

static void f(letter y)
	{
		y.a=(float) 45.3;
	}

letter x=new letter();
x.a=(float) 63.2;
System.out.println("1:x.a "+x.a);
f(x);
System.out.print("2:x.a "+x.a );

输出：

1:x.a 63.2
2:x.a 45.3

3.关系运算符

3.1."=="与"equals()":

Integer n1=new Integer(47);
Integer n2=new Integer(47);
System.out.println(n1==n2);//false
System.out.println(n1！=n2);//true

对应上述的结果：虽然对象的内容相同，但是对象的引用却是不相同的，而上述这两个运算符比较的就是对象的引用；所以此时我们的equals()就出场了。

System.out.println(n1.equals(n2));//true

但是在自己创建的类当中这个答案就又是false；//等到相应的章节时再补解析

4.短路（以为回到了物理，害）

boolean b=test1(0)&&test2(2)&&teat3(3);
当遇到结果是true则继续执行下一个test2(2),如果test2(2)是false则将不会继续执行test3(3);一错全错，惨兮兮，我不要一错再错啦；

5.位运算符

有：&与、|或、^异或、~非（是一元操作符所以不能与=相联用）、<<、>>、>>>；
5.1. 关于<<:空位补0，被移除的最高位丢弃，空位补0；
5.5. 关于>>：被移位的二进制最高位是0，右移后，空缺位置补0； 若最高位是1，空缺位补1；
5.3 .关于>>>：（无符号位）空缺位都用0补；
5.4. 关于异或操作符，可以很好的解决一些问题，待我找找以前例题；

题目是找出只出现过一次的数字。
class Solution {
    public int singleNumber(int[] nums) {
        int ans = 0;
        for(int num: nums) {//类型 变量：数组//遍历数组
            ans ^= num;//异或运算//运用了交换律a+a=0;a+0=a;a+a+b=b;
        }
        return ans;


    }
}

5.5 .按位操作符与逻辑运算符有着相同的效果，只是不会像上一次例子那样中途短路；
5.6 例题：一道老式的面试题：
最高效的方式计算2*8：

2<<3或者8<<1

6.截尾与舍入

将float或者double类型的转换为int的类型时，会对数字进行截尾，如果要想得到舍入的结果，就需要用java.long.Math中的round()方法；

import java.util.*;

public class J截尾与舍入 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner (System.in);
		double a=0.7,b=0.3;
		float aa=0.7f,bb=0.3f;
		/*
		 * 截尾
		 */
		System.out.println("(int)double a="+(int)a);
		System.out.println("(int)double b="+(int)b);
		System.out.println("(int)float aa="+(int)aa);
		System.out.println("(int)float bb="+(int)bb);
		
		/*
		 * 舍入
		 * 用java.long.Math中的round（）方法
		 */
		System.out.println("Math.round(a)="+Math.round(a));
		System.out.println("(int)double b="+Math.round(b));
		System.out.println("(int)float aa="+Math.round(aa));
		System.out.println("(int)float bb="+Math.round(bb));
	}

}

二.数据的比较（暂时先放在这里）

1.比较double数据是否相等的方法

/**
 * 1.比较double数据是否相等的方法
 * @又又
 */
import java.util.*;
import java.math.BigDecimal;

public class D第三章操作符 {

	public static void main(String[] args) {
		/*
		 * 方法一：若比较的数据精度要求不高，那么就定义一个aa=0.001；
		 * 对于精度要求不高的，小于0.001的数据都可以认为是等于0；
		 */
		final double aa=0.0125;
		double bb=0.001;
		if(Math.abs(bb-0)<aa)
		{
			System.out.println("true");
		}
		else {
			System.out.println("你个小憨憨，你错啦");
		}
		System.out.println(Math.abs(bb-0)<aa);
		
		/*
		 * 方法二：转换成字符串之后用equals方法比较；只适用于比较精度相同的数据；
		 */
		System.out.println(Double.toString(bb).equals(Double.toString(aa)));
		
		/*
		 * 方法三：使用BigDecimal类型的equals方法或者compareTo方法；但是要有类加载；
		 */
		System.out.println(new BigDecimal(aa).equals(new BigDecimal(bb)));
		System.out.println(new BigDecimal(aa).compareTo(new BigDecimal(bb))/*==0*/);//==0可写可不写
	
	}

}

输出：

true
true
false
false
1

equals方法：比较之前先判断要比较的数据类型，对象一致再同时判断精确度和值是否一致；

compareTo方法：不会比较精确度，把精确度低的那一个对象转换为高精确度，只比较数值的大小；

三.字符串

1.访问字符串

public class S字符串 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner (System.in);
		String s=new String();
		s=in.nextLine();
		/*
		 * 访问String里面的字符
		 */
		System.out.println(s.charAt(0));
		
		/*
		 * 得到字串
		 */
		System.out.println(s.substring(1));
		System.out.println(s.substring(1,5));
		
		/*
		 * 寻找字符，如果没有找到则为-1
		 */
		String a="abcdefgh";
		System.out.println(a.indexOf(98));//得到某个字符所在的位置
		System.out.println(a.indexOf('a'));//得到某个字符的位置
		System.out.println(a.indexOf('a',0));//从n号位置开始寻找某个字符(' ',n)
		System.out.println(a.indexOf("cd"));//找到字符串t所在的位置
	}

}

输出：

qwertyu
q
wertyu
wert
1
0
0
2

从右边开始寻找：
1.a.lastIndexOf('');
2.a.lastIndexOf('',n);
3.a.lastIndexOf(" ");

2.比较字符串的内容是否相等：

不能用'==',因为'=='比较的是双方的地址，而不会比较内容；
应该用equals()：进行的是字符串的对象的比较，他的原型是：boolean equals (Object obj);

3.比较大小：

.compareTo(); >则输出1；<则-1；相等则0.
总结：

1.==操作符既可以用于比较基本的数据类型，也可以用于比较对象，而equals只可以用于对象之间的比较。
2.在比较String类型的对象时，“==”操作符的原理只有两个变量是同一对象的引用时才会返回true，而equals方法只要两个变量的内容相同则返回true。
3.对象进行比较时，equals方法默认的原理是判断两者的内存地址是否相同，所以默认情况下与“==”操作符返回的结果相同，但是这里应该发现差别，也就是equals方法可以被重写—用户可以定制自己的equals方法，而“==”操作符不能被重写。

四.控制程序流程

1.for

public class K控制程序流程 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(char c=0;c<128;c++)
		{
			if(Character.isLowerCase(c))
			{
				System.out.println("value:"+(int)c+"character:"+c);
			}
		}
	}

}

输出结果：

value:97character:a
value:98character:b
value:99character:c
value:100character:d
value:101character:e
value:102character:f
.....

注：这个程序中使用了java.lang.Character包装器类，这个类不但能把char基本类型的值包装近对象，还提供了别的用法，这里用到了static isLowerCase()方法来检查字母是否为小写；

2.foreach

public class K控制程序流程 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(char c:"liyouyou".toCharArray())
		{
			System.out.print(c+" ");
		}
	}

}

输出结果：

l i y o u y o u 

注：String类有一个方法toCharArray()，它返回一个char数组，像上面一样迭代字符串里面的所有字符；

3.标签

标签是后面有冒号的标识符：

public class K控制程序流程{
	public static void main(String[] args)
	{
		int i=0;
		outer:
			while(true)
			{
				System.out.println("outer while loop");
				{
					while(true)
					{
						i++;
						System.out.println("i=:"+i);
						if(i==1)
						{
							System.out.println("continue");
							continue;
						}
						{
							if(i==3)
							{
								System.out.println("contiue outer");
								continue outer;
							}
							if(i==5)
							{
								System.out.println("break");
								break;
							}
							if(i==7)
							{
								System.out.println("break outer");
								break outer;
							}
						}
					}
				}
			}
	}

}

输出结果：

outer while loop
i=:1
continue
i=:2
i=:3
contiue outer
outer while loop//这一句是如何来的？是因为当i==3的时候，后面接的是continue outer；所以带标签的continue会到达标签的位置，并重新进入紧接着在那个标签之后的循环
i=:4
i=:5
break
outer while loop
i=:6
i=:7
break outer

五.初始化与清理

1.用构造器确保初始化

关于构造器：是一类特殊类型的方法，没有返回值

class aa{
		aa(){//this is the constructor
			System.out.print("bb"+" ");
		}
		
	}
public class Y1用构造器确保初始化 {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<5;i++)
		{
			new aa();
		}
	}

}

output:
bb bb bb bb bb 

2.重载构造器与重载方法

class tree{
	int len;
	tree()
	{
		System.out.println("shumu");
		int len=0;
	}
	tree(int i){
		int len=i;
		System.out.println("now len="+len);
	}
	void info()
	{
		System.out.println("shumu is="+len);
	}
	void info(String a)
	{
		System.out.println(a+" len="+len);
	}
}
public class F方法重载 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=0;i<3;i++)
		{
			tree t=new tree(i);
			t.info();
			t.info("method");
		}
		new tree();
	}

}

output:
now len=0
shumu is=0
method len=0
now len=1
shumu is=0
method len=0
now len=2
shumu is=0
method len=0
shumu