黑马程序员-Java的数组(由基本类型构成)和算法

时间:2021-09-01 13:18:35

                                                  -----------android培训、java培训、java学习型技术博客、期待与您交流!------------

                                                                             Java的数组要点总结

1、数组是基本数据类型和字符串类型的容器(引用数据类型),而集合是类数据类型的容器;
  
2、数组定义的格式:
   (1)一般格式: 
       元素类型[] 数组名 = new  元素类型[元素个数或者数组长度];
   其中,元素类型[] 数组名是一个引用数据类型,存放在栈中;
   new  元素类型[元素个数或者数组长度]存放在堆中数组对象,继承自Object。

   (2)定义和静态初始化
        元素类型[] 数组名 = {,,};
 元素类型[] 数组名 = new  元素类型[元素个数或者数组长度]{
  ,,,,,,,};
   注意:别忘了末尾的;


3、未初始化的数组的默认值问题,就是保存的基本类型的默认初始值
 int[] rfInit = new int[3];
 System.out.println(rfInit[0]);//0
 String[] strInit = new String[3];
 System.out.println(strInit[0]);//null


4、数组使用中常见问题

   (1)数组越界:编译没有问题,但运行时报错。
        int[] arr = new int[3];
 System.out.println(arr[3]);
 //ArrayIndexOfBoundsException3:操作数组时,访问到了
 数组中不存在的角标。
    注:角标的最大值是长度减1;

   (2)数组指向错误
        String[]  strNull = null;
 System.out.println(strNull[0]);
 //NullPointException :空指针异常,当引用没有任何指向为
 null的情况,该引用还在用于操作实体。

5、数组引用值:
   int[]  a = {1,2,3,4};
   System.out.println(a);
   //结果: [I@1db9742 ,这个就是数组的引用值;其中,
   [表示为数组,I表示存放类型,1db9742哈希值表示在内存中的存放
   的十六进制地址。

6、数组操作(算法)
   遍历、最大/最小值、排序(冒泡、选择和直接插入)、查找(折半)、删除数组元素操作
   和进制转化

   (1)遍历
        int[] arr = new int[3];
    通过数组的属性arr.length可以获取数组的长度。
   (2)最大/最小值:
        a、存放值
        (注:不能把存放最大值的变量赋值为0,因为数组中有负数,就会产生问题。)
 b、存放角标
 (注:存放角标的值可以为0,因为它代表数组的0角标数据)
   (3)排序:从小到大
        a、选择:内循环一次比较,选择出最小的放在最前面,所以减少前面
 比较完的数量;(注:暂时保存最大或者最小值下标,最后再交换是一个
 优化的方法。)
 b、冒泡:内循环一次比较,最小值向前移动,最大值的沉底;所以减少
 后面比较完的数量,
   -x:让每一次比较的元素减少,-1:避免角标越界。
 c、直接插入排序:就是拿出一个空位置,保存起来,接下来把这个位置前面
 的元素和这个位置的值比较;如果大于,就一种元素,如果小于,就结束比较,
 保存元素在现在的位置上。

 注:java中,用Arrays.sort()排序;java中已经定义好的一种排序方式。
 开发中,对数组排序。要使用该句代码。

    (4)查找:折半查找
        先排序,后折半比较;得到相应的数组的下标值。

import  java.util.*;

class  ArrayTest2{
	//选择排序
	public static  void  selectSort(int[] arr){
		//int temp = 0;

		for(int i=0;i<arr.length-1;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					//temp = arr[i];
					//arr[i] = arr[j];
					//arr[j] = temp;
					swap(arr,i,j);
				}
			}
		}
	}

	//冒泡排序或者就沉底排序
	public static void  bubbleSort(int[] arr){
		//int temp =0;
		for(int i =0;i<arr.length-1;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					//temp = arr[i];
					//arr[i] = arr[j];
					//arr[j] = temp;
					swap(arr,j,j+1);
				}
			}
		}
	}

	//优化后的选择排序
	public static void  optimizeSort(int[] arr){
		int min;
		for(int i=0;i<arr.length-1;i++){
			min =i;
			for(int j=i+1;j<arr.length;j++){
				if(arr[min]>arr[j]){
					min = j;	
				}
			}
			swap(arr,i,min);
		}
	}

	//直接插入排序
	public static void  insertSort(int[] arr){
		for (int i = 1; i < arr.length; i++)
		{
			//从1角标开始取值,取出一个空位置来
			if (arr[i - 1] > arr[i])
			{
				//一次插入的过程
				int temp = arr[i];
				int j = i;

				//比较移动位置,因为有空位置存在,不会就是元素
				while (j > 0 && arr[j - 1] > temp)
				{
					arr[j] = arr[j - 1];
					j--;
				}

				//放在合适的位置上
				arr[j] = temp;
			}
		}
	}

	public static void   swap(int[] arr,int x,int y){
		int temp = 0;
		temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}

	public  static void printArray(int[] arr){
		System.out.print("[");
		for(int i=0;i<arr.length;i++){
			if(i!=arr.length-1)
				System.out.print(arr[i]+", ");
			else
				System.out.println(arr[i]+" ]");
		}

	}

	public static void main(String[] args){
		int[] a = new int[]{3,1,4,9,6,2};
		printArray(a);

        //selectSort(a);
        //printArray(a);

		//bubbleSort(a);
		//printArray(a);

		//optimizeSort(a);
		//printArray(a);

		insertSort(a);
		printArray(a);

		//Arrays.sort(a);
		//printArray(a);
	}
}


 

    (5)删除数组元素的操作
   public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length);
   利用System.arraycopy()实现删除数组某个元素的操作。

public class JudgeArrayIsRepeat {
	public static int[]  judgeInt(int[] a,int x) {
		int index = x-1 ;
		int[] b  = new int[a.length-1];
		System.arraycopy(a, 0, b, 0, index);
		System.arraycopy(a, index+1, b, index, b.length-index);
//		for (int i = 0; i < b.length; i++) {
//			System.out.print(b[i]+" ");
//		}
		return  b;	
	}
	
	public  static void  main(String[] args){
		
		int[] a  = {1,2,3,4,5};
		int[] c = null;
		c = JudgeArrayIsRepeat.judgeInt(a,3);
		for (int i = 0; i < c.length; i++) {
			System.out.print(c[i]+" ");
		}
	}
}


 

     (6)进制转化
        a、十进制转二进制:查表法
    0  1  -二进制
    0  1
 b、十进制转八进制:查表法
    0  1  2  3  4  5  6  7  -八进制
    0  1  2  3  4  5  6  7

        c、十进制转十六进制:查表法
    0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F -十六进制
    0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15
    利用数组的值与下标的对应,将所有临时元素存储起来,建立相应的对应关系。
7、二位数组
  
   (1)默认初始化问题
 //Cannot specify an array dimension after an empty dimension  
 int[][] arrs  = new int[][2];//这种定义方式不行 
 
 //默认初始化,因为没有初始化一维数组,所以arr[0]引用都是默认值null。
 int[][] arr  = new int[3][];
 System.out.println(arr); //[[I@1db9742
 System.out.println(arr[0]);//null

 arr[0] = new int[3];
   (2)静态初始化的方式
        元素类型[][] 数组名 ={{,,},{,,},{,,}};
       
8、数组的定义时括号的位置
    int[] x; int x[];
    int[][] y; int y[][]; int[] y[];
    所以
    int[] x,y[];//x一维,y二维。
    注:写程序时,不要这么定义,容易产生歧义。