排序&查找&Aarray&封装类型

排序&查找

描述：基本排序法有,插入排序，归并排序，快速排序，冒泡排序，希尔排序，选择排序。

• 插入排序：

  • 直接在原本的数组上，直接将后面无序的元素插入到前面有序的数组中，需要一个辅助空间即可。
  • 常用的有两种，一种是直接插入排序，一种是折半插入排序。

• 归并排序：

• 快速排序：

• 冒泡排序：

  • 每一趟将最大的值或者是最小的排到端位置，通过n趟实现完整排序。

  public static void popSort(int[] arrayAa) {
  	int length = arrayAa.length;
  	System.out.println("length: " + length);
  	// 自小到大的排序。
  	for (int i = 0; i < length; ++i) {
  		for (int j = 0; j < length - i - 1; ++j)
  			if (arrayAa[j] > arrayAa[j + 1]) {
  				swapCc(arrayAa, j, j + 1);
  				//swap(arrayAa[j], arrayAa[j]); 无法实现交换。
  			}
  	}	
  
  }
  
  public static void swapCc(int[] data, int i, int j) {
  	int temp = data[i];
  	data[i] = data[j];
  	data[j] = temp;
  }
  

• 希尔排序：

• 选择排序：

考虑到java提供了具体的库文件，而本人会该类排序&查找方式，不在赘述。

Arrays工具类

描述：针对数组进行操作-查找&排序的工具类，无构造方法。

• public static String toString(int[] a) //数组转为字符串.
• public static void sort(int[] a) //对数组进行操作.
• public static int binarySearch(int[] a, int key) //二分查找法.

  /*for example*/
  package TestAa;
  import java.util.Arrays;
  
  public class CompareAa {
  	public static void main(String[] args) {
  		int[] acc = new int[20];
  		for (int i = 0; i < 20; ++i) {
  			acc[i] = (int) (101 * Math.random());
  		}
  		System.out.println("排序前：" + Arrays.toString(acc));
  		Arrays.sort(acc); // 底部为快排.
  		System.out.println("排序后：" + Arrays.toString(acc));
  		System.out.println("BinarySearch:" + Arrays.binarySearch(acc, 45));
  	}
  }
  
  

基本类型包装类

• 目的是用于基本类型与字符串之间的转化。为了对基本类型的进行更多的操作，Java每一种基本类型都提供了对应的基本类型。

   如：byte, short, int, long, float, double, char, boolean。对应如下：
   Byte, Short, Integer, Long, Float, Double, Character, Boolean.
  

• Integer
  描述：整数的操作工具类.

  package TestAa;
  
  public class CompareAa {
  	public static void main(String[] args) {
  		// public static String toBinaryString(int i) 二进制
  		System.out.println(Integer.toBinaryString(100));
  		// public static String toOctalString(int i) 八进制
  		System.out.println(Integer.toOctalString(100));
  		// public static String toHexString() 十六进制
  		System.out.println(Integer.toHexString(100));
  
  		System.out.println(Integer.MAX_VALUE);
  		System.out.println(Integer.MIN_VALUE);
  	}
  
  }
  
  

  • Integer的构造方法

  Integer i = new Integer(100);	//public Integer(int value);
  Integer ii = new Integer("100");	//public Integer(String s)
  
  

• int&String转换

  • int–>String

  实现一：
  int numer = 10;
  String s1 = ""+number；
  String s2 = String.valueOf(number)
  
  实现二：
  integer i = new Integer(100);
  String s3 = i.toString();
  
  实现三：
  String s4 = Integer.toString(100);
  

  • String–>int

  实现一：
  Integer i = new Integer("100");
  int Aa = i.intValue();
  
  实现二：
  int y = Integer.paseInt("100")		//public static int paseInt(String s) throw; NumberFormatException
  
  

  • String–>到任意的数据类型，使用封装类.pase封装类。

  /*for example:*/
  float fl = Float.paseFloat("12.5")
  
  

• JDk5新特性

  • 自动装箱/拆箱：Integer i = new Integer(100);
  • 其实这个不是想象的简单直接，实际Integer是一个引用类型，而int为基本的数据类型，在自动?/拆的情况下才实现的。

  Integer i = Integer.valueOf(100)	//返回int数值100的一个Integer实例
  Integer i = Interger.valueOf(i.intValue()+100); 	//拆箱运算，再装回去.
  
  

• Integer踩坑

  package TestAa;
  
  public class CompareAa {
  	public static void main(String[] args) {
  		/*
  		 * 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据.Integer ii = Integer.valueOf(127);
  		 */
  		Integer i1 = new Integer(127);
  		Integer i2 = new Integer(127);
  		System.out.println(i1 == i2);
  		System.out.println(i1.equals(i2));
  		System.out.println("-----------");
  
  		Integer i3 = new Integer(128);
  		Integer i4 = new Integer(128);
  		System.out.println(i3 == i4);
  		System.out.println(i3.equals(i4));
  		System.out.println("-----------");
  
  		Integer i5 = 128;
  		Integer i6 = 128;
  		System.out.println(i5 == i6);
  		System.out.println(i5.equals(i6));
  		System.out.println("-----------");
  
  		Integer i7 = 127;
  		Integer i8 = 127;
  		System.out.println(i7 == i8);
  		System.out.println(i7.equals(i8));
  	}
  }
  
  

上式的执行结果如下：
```
false
true
-----------
false
true
-----------
false
true
-----------
true
true

```

• Character类
  • 仅有一个构造方法：Character ch = new Character(‘a’);
  • 常用成员方法：

  public static boolean isUpperCase(char ch);
  
  public static boolean isLowerCase(char ch);
  
  public static boolean isDigit(char ch);	//判断字符是否为数值字符。
  
  public static char toUpperCase(char ch);
  
  public static char toLowerCase(char ch)
  

  • 统计串的字母大小写和数值的个数.