数组知识总结

初始化

      静态初始化  
      数据类型[]  数组名称 = {值,值};    数据类型[]  数组名称 = new 数据类型[]{值,值};
	  动态初始化 
	  数据类型[]  数组名称 = new 数据类型[长度];      

lenth的归属

数组只有.length属性，String有.length()方法.

数组去重

package com.offcn.Array;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

public class Array_Test2 {
	/**
	 * 数组去重
	 */
	public static void main(String[] args) {
		int[] str={5,6,6,8,8,7,4};
		method_1(str);
		Integer[] str2={5,6,6,8,8,7,4};
		method_2(str2);
//		method_3(str2);
	}
	public static int[] method_1(int[] arr) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < arr.length; i++) {
			if(!list.contains(arr[i])) {
				list.add(arr[i]);
			}
		}
		
		Integer[] array2 = list.toArray(new Integer[list.size()]);
		System.out.println(Arrays.toString(array2));
		return null ;
	}
	public static void method_2(Integer[] arr) {
		/**
		   *  无序 唯一 各种快
		   *  自然排序: 
		 * 1--需要被排序的类实现Comparable<T>接口
         * 2--重写其中的 comparato
                       * 自定义比较器排序; 
		 * 1--这种方法需要一个新的类实现Comparator<T>接口
		 * 2--重写其中的Compare 方法
		 */
		TreeSet<Integer> hset = new TreeSet<Integer>(Arrays.asList(arr));
		Iterator i = hset.iterator();
		while(i.hasNext()){
		     System.out.println(i.next());
		} 
	}
	
	public static void method_3(Integer[] arr) {
		/**
		 * HashSet   无序不重复,可排序
		   * 因为HashSet的存储是由HashCode决定的。当存入数据时HashCode会计算该元素的位置。
		   * 然后根据计算出的相应的数值，把元素存入到对应的位置中。
		   * 所以当我们顺序遍历的时候会发现存入数据的顺序和输出数据的顺序不一致，
		   * 这就是HashSet的无序性。
		 */
		
		List<Integer> asList = Arrays.asList(arr);
		HashSet<Integer> hashSet = new HashSet<Integer>(asList);
		System.out.println(hashSet);
	}

}

细节null与空

package com.offcn.Array;

public class Array_Test3 {
	/**
	 * String 默认初始化是空字符串
	   *   引用数据类型，引用后未赋值则默认为null
	 * @param args
	 */
	public static void main(String[] args) {
		String[] stringArray = new String[3]; // 各元素的值默认为null
		for (int i = 0; i < stringArray.length; i++) {
			System.out.println(stringArray[i]); //打印null
		}
		for (int i = 0; i < stringArray.length; i++) { // 对各元素进行初始化，但没有赋值。
		stringArray[i] = new String();
		System.out.println(stringArray[i]);           //打印空
		}
		String str = new String();
		System.out.println("------"+str);
		
	}
}

创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同

package com.offcn.Array;

import java.util.Random;

public class Array_Test4 {
	/**
	   * 创建一个长度为6的int型数组，要求取值为1-30，同时元素值各不相同
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = new int[6];
		int[] method_1 = method_1(arr);
		for (int i = 0; i < method_1.length; i++) {
			System.out.println(method_1[i]);
		}
	}
	public static int[] method_1(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random()*30)+1;
			for (int j = 0; j < i; j++) {
				if(arr[i]==arr[j]) {
					i--;  //删除重复值，附加新值
					break;
				}
			}
		}
		return arr;
	}
}

回形针算法

package com.offcn.Array;

public class Test {
	public static void main(String[] args) {
		/**
		   * 回形针算法,想象成坐标轴
		 */
		int k = 6;
		int[][] arr = new int[k][k]; //定义数组
		int count = 0;//定义数据开始节点，从0开始
		int minX = 0;//使用坐标轴，X轴起点----minX从0开始
		int minY = 0;//使用坐标轴，Y轴起点----minY从0开始
		int maxX = k-1;//使用坐标轴，X轴终点----maxX从(最大值-1)结束
		int maxY = k-1;//使用坐标轴，Y轴终点----maxY从(最大值-1)结束
		while (minX<=maxX) {
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

例题

并对错误的答案加上单行注释，写出错误的原因。
A, float[]=new float[3]; // 没有名称
B, float f2[]=new float[];// 非静态初始化也非动态初始化
C, float[] f1=new float[3]; 对
D, boolean[] b={"true","false","true"};  //错  加字符串为String
E, double f4[]={1,3,5}; // 对  静态初始化
F, int f5[]=new int[3]{2,3,4}; // 拖出去砍了
G, float f4[]={1.2F,3.0,5.4};//  默认是double 所以报错，当是整数时，默认int 可以自动类型提升

冒泡排序

package com.offcn.Array;

import java.util.Arrays;

public class Test1 {
	/**
	 * 冒泡排序
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = {100,1,2,4,6,12,45,12,65,23,12,124};
		System.out.println("排序之前：\n"+Arrays.toString(arr));
		for (int i = 0; i < arr.length-1; i++) { // 最后一次不用排序
			for (int j = 0; j < arr.length-1-i; j++) { // -1 是因为防止第一次地址溢出，-i是因为已经排序好了，不用了
				if(arr[j]>arr[j+1]) {
					int temp = arr[j+1];
					arr[j+1] = arr[j];
					arr[j] = temp;
				}
				
			}
		}
		System.out.println("排序之后：\n"+Arrays.toString(arr));
	}

}