学习笔记 Java_毕向东_数组_面向对象 2014.7.31

一、数组

1、 折半查找。代码：MyArrayTest4.java

class MyArrayTest4 
{
	//查找元素，返回脚标
	static int getIndex(int[] arr, int element)
	{
		for(int x = 0; x < arr.length; x++)
		{
			if(arr[x] == element)
				return x;
		}
		return -1;  //如果数组中没有和elenment相等的元素，就返回-1
	}

	static int getIndex_2(int[] arr, int element)
	{
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		while(min <= max) 
		{
			if(arr[mid] > element)
				max = mid - 1;
			else if(arr[mid] < element)
			{
				min = mid + 1;
				//System.out.print("min=" + min);
			}
			mid = (min + max) / 2;
			//System.out.println("mid=" + mid + ",min=" + min + ",max=" + max);
			if(arr[mid] == element)
				return mid;
		}
		return min;
	}

    //折半查找。（将数组先按从小到大的顺序排好序）
	static int halfSearch(int[] arr, int element)
	{
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		while(arr[mid] != element)  //————————————
		{
			if(arr[mid] < element)
				min = mid + 1;
			else
				max = mid - 1;

			if(max < min)
				return -1;
			mid = (min + max) / 2;
		}
		return mid;
	}  	

	//折半查找的第二种方法
	static int halfSearch_2(int[] arr, int element)
	{
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max) / 2;
		while(min <= max)  //————————————
		{
			if(arr[mid] > element)
				max = mid - 1;
			else if(arr[mid] < element)
				min = mid + 1;
			mid = (min + max) / 2;
			if(arr[mid] == element)
				return mid;
		}
		return -1;
	}

	public static void main(String[] args) 
	{
		int[] arr = {1,2,3,4,7};
//		System.out.println("index=" + getIndex(arr, 4));

//		System.out.println("index=" + halfSearch(arr, 4));
		System.out.println("index=" + halfSearch_2(arr, 4));

		System.out.println("index=" + getIndex_2(arr, 5));
	}
}

 在有序数组中插入元素，依然有序（基于折半）（可能不会让你写程序，但是要知道这个思想）：getIndex_2

2、进制转换。

1. 十进制 ——〉二进制：（模2除2），反转（StringBuffer reverse功能）

   	//十进制 --> 二进制
   	static void toBin(int num)
   	{
   		StringBuffer sb = new StringBuffer();
   		while(num > 0)
   		{
   			sb.append(num % 2);
   			num = num / 2;
   		}
   		System.out.println(sb.reverse());
   	}
   

2. 十进制 ——〉十六进制

   	//十进制 --> 十六进制
   	static void toHex(int num)
   	{
   		StringBuffer sb = new StringBuffer();
   		for(int x = 0; x < 8; x++)  //循环8次，就是32位了
   		{
   			int siwei = num & 15;
   			if(siwei > 9)
   				//System.out.println((char)(siwei - 10 + 'A'));
   				sb.append((char)(siwei - 10 + 'A'));
   			else
   				//System.out.println(siwei);
   				sb.append(siwei);
   			num = num >>> 4;
   		}
   		System.out.println(sb.reverse());
   	}

3.  十进制 ——〉十六进制。查表法，用数组反转

   <pre class="java" name="code">	//十进制 --> 十六进制：用数组反转
   	static void toHex(int num)
   	{
   		char[] ch = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
           char[] arr = new char[8];
   		int pos = arr.length;
   		while(num != 0)
   		{
   			int temp = num & 15;
   			arr[--pos] = ch[temp];
   			num = num >>> 4;
   		}
   
   		for(int x = pos; x < arr.length; x++)
   		{
   			System.out.print(arr[x] + ",");
   		}
   		System.out.println();
   	}
   

4. 十进制 ——〉二进制。查表法

   	//十进制 --> 二进制。查表法
   	static void toBin(int num)
   	{
   		char[] ch = {'0', '1'};
   		char[] arr = new char[8];
   		int pos = arr.length;
   		
   		while(num != 0)  //这种方法不能算负数
   		{
   			int temp = num % 2;
   			arr[--pos] = ch[temp];
   			num = num / 2;
   		}
   
   		for(int x = pos; x < arr.length; x++)
   		{
   			System.out.print(arr[x]);
   		}
   		System.out.println();
   	}
   
   	//这个可以算负数
   	static void toBin_2(int num)
   	{
   		char[] ch = {'0', '1'};
   		char[] arr = new char[32];
   		int pos = arr.length;
   
   		while(num != 0)
   		{
   			int temp = num & 1;
   			arr[--pos] = ch[temp];
   			num = num >>> 1;
   		}
   
   		for(int x = pos; x < arr.length; x++)
   			System.out.print(arr[x]);
   		System.out.println();
   	} 

5. 进制转换优化（把转换的共性写成一个函数）

   static void toBin(int num)
   	{
   		trans(num, 1, 1);
   	}
   
   	static void toHex(int num)
   	{
   		trans(num, 15, 4);
   	}
   
   	static void trans(int num, int base, int offset)
   	{
   		if(num == 0)
   		{
   			System.out.println(0);
   			return ;
   		}
   
   		char[] ch = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
   		char[] arr = new char[32];
   		int pos = arr.length;
   
   		while(num != 0)
   		{
   			int temp = num & base;
   			arr[--pos] = ch[temp];
   			num = num >>> offset;
   		}
   
   		for(int x = pos; x < arr.length; x++)
   		{
   			System.out.print(arr[x]);
   		}
   		System.out.println();
   	}

 3、二维数组

1.  格式：

   int[][] a = new int[3][4];  //3行4列
   		//一维数组的名称为arr[0],arr[1],arr[2]。a输出二维数组的引用，a[0]输出一维数组的引用
   		System.out.println(a.length);  //二维数组的长度为3
   		System.out.println(a[0].length);  //二维数组中第一个一维数组的长度为4
   		
   		int[][] b = new int[3][];  //这三个一维数组没有初始化，所以默认初始化，因为数组是引用类型，所以为null。如：b[1]输出null
   		//可以对这三个一维数组分别初始化
   		b[0] = new int[3];
   		b[1] = new int[1];
   		b[2] = new int[2];
   	
   		int[][] c = {{1,2}, {3,4,5}, {6,7}};
   		//应用
   		int sum = 0;
   		for(int x = 0; x < c.length; x++)
   		{
   			for(int y = 0; y < c[x].length; y++)
   				sum += c[x][y];
   		}
   		System.out.println("sum=" + sum);

 

二、面向对象

1、private：只在本类中有效

2、构造函数

3、构造代码块

1. 作用：给对象进行初始化。
2. 对象一建立就运行，而且优先于构造函数执行。
3. 和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

   	{
   		System.out.println("person code run");
   		cry();
   	}

4. 构造代码快中定义的是不同对象共性的初始化内容。