JAVASE基础 容易出现错误的点 总结

数据类型相关

		byte b1 = 1;
		byte b2 = 2;
		//b2 = (byte)(b2+b1); //报错。， 需要强制类型转换
		b2+=b1;  //b2 = b2+ b1;	 b2+=b1 在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换了。
		System.out.println("b2 : "+ b2);

		byte b  = 10;
		long l = 30;
		System.out.println(l>b); //两个不同类型的数据是否可以比较呢.,可以的，但是两个不同类型的数据必须是兼用的数据。
		//这个比较的过程会先把b转换了long类型的数据，然后再进行比较 。

运算符相关

		//交换两个变量的值,不准出现第三方变量。
		int a = 3;
		int b = 5;
		
		/*
		第一种方式： 定义第三方变量。
		int temp = a;  //3 
		a = b; //a = 5 
		b = temp; 
		
		方式2：相加法， 缺点： 两个int类型的数据相加，有可能会出现超出int的表示范围。
		
		a = a+b;  // a =8
		b = a-b; //b = 8 - 5 = 3
		a = a-b; // a = 8 - 3 = 5
		
		方式3： 可以使用异或。 缺点： 逻辑不清晰。
		*/
		a = a^b;  // a = 3^5
		b = a^b;  // b = (3^5)^5 = 3
		a = a^b; //  a = (5^3)^3 = 5 
		System.out.println("a = "+ a+" b="+b);

/*
移位运算符：
	<<(左移)
规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移 的位数.
	3<<1 = 3 *2(1) = 6;
	3<<2 = 3*2(2) = 12
	3<<3 = 3*2(3) = 24
	
	>>(右移)

规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。

	3>>1 = 3 / 2(1) = 1
	3>>2 = 3 / 2(2) = 0 。。

	
	>>>(无符号右移) ：

无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，
如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都
统一使用0补。


笔试题目：使用最高的效率算出2乘以8的结果。
		2<<3 = 2*2(3) = 16;
*/
/*
		左移
		System.out.println(3<<1); // 6 
		System.out.println(3<<2); // 12
		System.out.println(3<<3); // 24 
		
		右移：
		*/
		System.out.println(3>>>1); // 1 
		System.out.println(3>>>2);  //0 

/*
使用异或对图片数据进行加密.
规律： 如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
*/
import java.io.*;
class ImageTest 
{
	public static void main(String[] args)  throws Exception
	{
		//找到图片文件
		File inFile = new File("d:\\加密的图片.jpg");
		File outFile = new File("d:\\解密的图片.jpg");

		//建立数据通道，让图片的二进制数据流入
		FileInputStream input = new FileInputStream(inFile);
		FileOutputStream output = new FileOutputStream(outFile);
		//边读，把读到的数据异或一个数据，把把数据写出

		int content = 0; //该变量是用于存储读取到的数据
		while((content = input.read())!=-1){  // 如果没有到文件的末尾，那么继续读取数据，读取到的数据已经存储到content变量中了。
			output.write(content^1024);
		}
	
			
		//关闭资源
		output.close();
		input.close();

	}
}

		//在java中，java编译器是不允许写废话。
		while(false){
			System.out.println("Hello World!");//无法访问的语句，此时编译这句会报错
		}

		//在java中，java编译器是不允许写废话。
		int count =0;
		while(true){
			System.out.println("Hello World!");
		}
		count++;//无法访问的语句，此时编译这句会报错

流程控制语句

//break目前位于内层的for循环，如何才能让break作用于外层 的for循环。
//	可以标记解决
aaa:for(int j = 0 ; j<4 ; j++){ // j=0 外层for循环
			bbb:for(int i = 0 ; i< 5 ; i++){  // i=0 内层for循环
				System.out.println("hello world"); // 1	
				break aaa;
			}
			
		}

排序

	//选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。
	public static void main(String[] args) 
	{
		int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
		selectSort(arr);
	}

	public static void selectSort(int[] arr){
		
		//把最大值放在首位置。
		for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
			for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
				if(arr[i]>arr[j]){
					//交换位置
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		

/*
		//把老二放在第二个位置
		for(int i = 2  ; i< arr.length ; i++){
			if(arr[i]>arr[1]){
				int temp = arr[i];
				arr[i] = arr[1];
				arr[1] = temp;
			}
		}
		

		//把老三放在第三个位置
		for(int i = 3  ; i< arr.length ; i++){
			if(arr[i]>arr[2]){
				int temp = arr[i];
				arr[i] = arr[2];
				arr[2] = temp;
			}
		}

		//把老四放在第四个位置
		for(int i = 4  ; i< arr.length ; i++){
			if(arr[i]>arr[3]){
				int temp = arr[i];
				arr[i] = arr[3];
				arr[3] = temp;
			}
		}

*/

		
		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}

	}

	//冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。
	public static void main(String[] args) 
	{
		int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
 		bubbleSort(arr);
	}


	public static void bubbleSort(int[] arr){
		// 把最大值放在最后一个位置
		for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
			for(int i = 0 ; i<arr.length-1-j  ; i++){  // 找出一个最大值  
				//相邻的元素比较
				if(arr[i]>arr[i+1]){
					int temp  = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}

/*
	
		//把老二放在倒数第二个位置上。
		for(int i = 0 ;  i <arr.length-1-1 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

	
		//把老三放在倒数第三个位置上。
		for(int i = 0 ;  i <arr.length-1-2 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

		//把老四放在倒数第四个位置上。
		for(int i = 0 ;  i <arr.length-1-3 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

*/


		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}
		
	}

	//折半查找法(二分法): 使用前提必需是有序的数组。
	public static void main(String[] args) 
	{
		int[] arr = {12,16,19,23,54};
		//int index = searchEle(arr,23);
		int index = halfSearch(arr,116);
		System.out.println("元素所在的索引值是："+ index);
	}
	
		
	public static int halfSearch(int[] arr, int target){
		//定义三个变量分别记录最大、最小、中间的查找范围索引值
		int max = arr.length-1;
		int min = 0;
		int mid = (max+min)/2;
		while(true){
			if(target>arr[mid]){
				min = mid+1;
			}else if(target<arr[mid]){
				max = mid -1;
			}else{
				//找到了元素
				return mid;
			}

			//没有找到的情况
			if (max<min){
				return -1;
			}

			//重新计算中间索引值
			mid = (min+max)/2;
		}
	
	}



	
	public static int searchEle(int[] arr, int target){
		for(int i = 0 ; i<arr.length ; i++){
			if(arr[i]==target){
				return i;
			}
		}
		return -1;
	}

字符串

new String("abc")创建了几个对象？
两个对象， 一个对象是 位于字符串常量池中，一个对象是位于堆内存中。

如果需要频繁修改字符串 的内容，建议使用字符串缓冲 类（StringBuffer）。
StringBuffer 其实就是一个存储字符 的容器。

使用Stringbuffer无 参的构造函数创建 一个对象时，默认的初始容量是多少？ 如果长度不够使用了，自动增长多少倍？

StringBuffer 底层是依赖了一个字符数组才能存储字符数据 的，该字符串数组默认 的初始容量是16， 如果字符数组的长度不够使用 死，自动增长1倍。

容器的具备 的行为：
	容器的具备 的行为
	String 
	增加
		append(boolean b)    可以添加任意类型 的数据到容器中
		insert(int offset, boolean b)  指定插入的索引值，插入对应 的内容。 
	删除
		delete(int start, int end)  根据指定的开始与结束的索引值删除对应的内容。
		deleteCharAt(int index)   根据指定 的索引值删除一个字符。
	修改
		replace(int start, int end, String str) 根据指定 的开始与结束索引值替代成指定的内容。
		reverse()   翻转字符串缓冲类的内容。  abc--->cba
        setCharAt(int index, char ch)  把指定索引值的字符替换指定的字符。 
        substring(int start, int end)  根据指定的索引值截取子串。
		ensureCapacity(int minimumCapacity)  指定StringBuffer内部的字符数组长度的。	
	查看
		indexOf(String str, int fromIndex) 查找指定的字符串第一次出现的索引值,并且指定开始查找的位置。
		lastIndexOf(String str) 
		capacity() 查看当前字符数组的长度。 
		length() 
		charAt(int index) 
		toString()   把字符串缓冲类的内容转成字符串返回。
		
StringBuffer 与 StringBuilder的相同处与不同处：
	相同点：
		1. 两个类都是字符串缓冲类。
		2. 两个类的方法都是一致的。
	不同点：
		1. StringBuffer是线程安全的,操作效率低 ，StringBuilder是线程非安全的,操作效率高。
		2. StringBuffer是jdk1.0出现 的，StringBuilder 是jdk1.5的时候出现的。	
推荐使用： StringBuilder，因为操作效率高。

其他

一个java应用程序至少有几个线程？
	至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。