学习笔记——day11（二维数组 排序）

二维数组

数组：
数据类型[] 变量名 = new 数据类型[10];

二维数组：
声明的时候： 行和列都需要声明出来

代码

public class Test01 {
	public static void main(String[] args) {
		
		// 二维数组声明
		int[][] arrs = new int[5][];
		
		//声明列
		arrs[0] = new int[3];// arrs这个二维数组中的第一个位置上存储的是一个3个长度的新数组
		
		
		
		
		System.out.println(arrs.length);
		System.out.println(arrs[0]);
		// 往二维数组中填充值
		arrs[0][0] = 10;
		arrs[0][1] = 20;
		
		//循环迭代当前数组的每个元素
		for(int i = 0;i<arrs.length;i++) {//循环行
			for(int j = 0;j<arrs[i].length;j++) {//列数
				System.out.println(arrs[i][j]);
			}
		}
		
		
		
		
		
	}
}

代码

public class Test02 {
	public static void main(String[] args) {
		//声明一个二维数组
		int[][] arrs = new int[5][3];
		
		
		//for循环填充值
		for(int i=0;i<arrs.length;i++) {//行
			for(int j = 0;j<arrs[i].length;j++) {//列
				arrs[i][j] = (int)(Math.random()*20+1);
			}
		}
		
		
		System.out.println("=======================");
		// 循环迭代
		for(int i=0;i<arrs.length;i++) {//行
			System.out.print("第"+(i)+"行：");
			for(int j = 0;j<arrs[i].length;j++) {//列
				System.out.print(arrs[i][j]+"\t");
			}
			System.out.println();
		}
		System.out.println("===");
		
		
		
	}
}

代码

/*
 *      <font style="font-wieght:bold;"></font>
 *      <em></em>
 *      <strong></strong>
 *      
 *  	数组工具类( 只针对int类型的数组 )
 *     		初始化一个10个长度的数组  数据33-150之间的随机数
 *     		添加一个元素到指定位置
 *     		添加元素到第一个位置
 *     		添加元素到最后一个位置		
 *     		删除指定位置元素
 *     		删除元素到第一个位置
 *     		删除元素到最后一个位置	
 *     		
 *     		查找元素：
 *     			根据元素内容查找当前元素的索引 
 *     		排序：对于数组从小的到大排序
 *     		复制一个数组到新数组中去
 *     		填充（根据值将数组中的所有值全部覆盖）
 *     		罗列数组中的所有内容		
 *     
 *     	动态的集合 手写集合框架
 *      java中的组数工具类  Arrays 
 *      		  排序  查找   填充  toString  复制
 * 
 */
public class TestMyArrayUtils {
	public static void main(String[] args) {
		//int[] arrs = new int[-1];
		
		int[] arr = new int[5];
		ArraysUtil.init(arr);
		
		
		System.out.println(ArraysUtil.toString(arr));
		
		
		/*
		 * arrs[0] = 20; System.out.println(arrs[0]);
		 * 
		 * ArraysUtil.init(arrs); System.out.println(arrs[0]);
		 */
		
		int[] arrs = new int[5];
		
		arrs[0] = 1;
		arrs[2] = 0;
		arrs[2] = 0;
		
		//添加元素到数组的指定位置中
		arrs[3] = 10;
		
		
		
		
		
	}
}

package com.mage.arrays.util;

/*
 *    
 *    
 *    LeetCode：167、217、219、287
 *    	编写排序方法：
 *    		冒泡
 *    			优化2次 
 *    		选择排序
 *    	编写搜索算法：
 *    		二分查找
 *    		
 *    		斐波那契查找法
 *    	
 *    
 *    
 *    
 *    
 *    
 *    
 */
public class ArrayList {
	
	private int[] arrs ;
	private static final int DEFAULT_CAPACITY = 10;
	private int size;//ArrayList中存储元素的个数
	private int capacity;//底层arrs数组的长度
	
	
	
	public ArrayList() {
		this(DEFAULT_CAPACITY);
	}
	
	public ArrayList(int capacity) {
		arrs = new int[capacity];
		this.capacity = capacity;
		this.size = 0;
	}
	
	/**
	 * 	返回当前ArrayList集合中的元素的个数
	 * @return
	 */
	public int size() {
		return this.size;
	}
	/**
	 * 	返回当前ArrayList底层数组的容量
	 * @return
	 */
	public int opacity() {
		return arrs.length;
	}
	
	/**
	 *  	返回当前数组是否为null
	 * @return
	 */
	public boolean isEmpty() {
		return this.size==0;
	}
	
	/**
	 * 	 添加元素到指定的位置上
	 * @param value 添加的元素
	 * @param index 添加的位置
	 */
	public void add(int value,int index) {
		if(index<0||index>size) {
			System.out.println("错误参数："+index);
			return;
		}
		// 添加元素的时候 size == arrs.length
		if(size==arrs.length) {
			resize(arrs.length*2);
		}
		
		//依次挪动数组中的元素 给待添加的元素腾出来位置
		for(int i =size-1;i>=index;i--) {
			arrs[i+1] = arrs[i];
		}
		arrs[index] = value;
		//最后做完之后
		size++;
	}
	
	/**
	 *  	添加首元素
	 * @param value
	 */
	public void addFirst(int value) {
		add(value,0);
	}
	
	/**
	 *  	添加尾元素
	 * @param value
	 */
	public void addLast(int value) {
		add(value,size);
	}
	
	/**
	 *   	查询是否存在指定的元素 
	 * @param value 查询的元素
	 * @return 元素内容
	 */
	public boolean contains(int value) {
		return getIndexByValue(value)!=-1;
	}
	
	
	/**
	 *  	查询指定元素在当前数组中的索引位置(只找一个)  
	 * @param value
	 * @return 查找的元素的所有 如果不存在返回-1
	 */
	public int getIndexByValue(int value) {
		for(int i= 0;i<size;i++) {
			if(arrs[i]==value) {
				return i;
			}
		}
		return -1;
	}
	

	/**
	 *      返回指定索引位置上的元素
	 * @param index 索引
	 * @return 元素    如果返回-1 代表当前数组的入参有误
	 */
	public int get(int index) {
		if(index<0||index>=size) {
			System.out.println("错误参数："+index);
			return -1;
		}
		return this.arrs[index];
	}
	
	
	/**
	 *       	修改数组中指定位置上的元素
	 * @param index  指定的索引
	 * @param value  修改之后的值
	 * @return  修改之前的值 如果索引有问题 返回-2
	 */
	public int set(int index,int value) {
		int oldValue = get(index);
		if(oldValue!=-1) {
			arrs[index]=value;
			return oldValue;
		}
		return -2;
	}
	
	/**
	 * 	根据索引删除元素
	 * @param index 索引
	 * @return 删除的元素   如果索引有误 返回-1
	 */
	public int remove(int index) {
		if(index<0||index>=size) {
			System.out.println("参数有误");
			return -1;
		}
		int ret = arrs[index];
		for(int i = index;i<size-1;i++) {
			arrs[i] = arrs[i+1];
		}
		
		size--;
		arrs[size]=0;
		
		if(size==arrs.length/4&&arrs.length/2>0) {
			resize(arrs.length/2);
		}
		
		return ret;
	}
	
	/**
	 *  	删除第一个元素
	 * @return
	 */
	public int removeFirst() {
		return remove(0);
	}
	
	/**
	 *  	删除最后元素
	 * @return
	 */
	public int removeLast() {
		return remove(size-1);
	}
	
	
	/**
	 * 	数组扩容操作
	 */
	private void resize(int capacity) {
		//有一个新的数组
		int[] newArrs = new int[capacity];
		// 拷贝
		copyOf(arrs, newArrs,Math.min(arrs.length, newArrs.length));
		//给引用
		arrs = newArrs;
		
	}
	
	
	/**
	 *  	数组复制
	 * @param src 源数组
	 * @param dest 目标数组
	 */
	private void copyOf(int[] src,int[] dest,int min) {
		//判定
		if(src==null||dest==null) {
			System.out.println("参数有误 数组为null");
			return;
		}
		
		if(src.length<=0||dest.length<=0) {
			System.out.println("参数有误 数组的长度有误");
			return;
		}
		
		
		for(int i = 0;i<min;i++) {
		    dest[i] = src[i];
		}
		
	}
	
	
	
	
	
	
	
	/**
	 * 获取当前ArrayList的内容
	 */
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("size:"+this.size+"opacity:"+this.arrs.length);
		sb.append("[");
		for(int i = 0;i<size;i++) {
			sb.append(arrs[i]);
			if(i!=size-1) {
				sb.append(",");
			}
		}
		sb.append("]");
		return sb.toString();
	}
	
	
	


	
}

测试代码

package com.mage.arrays;

import com.mage.arrays.util.ArrayList;

/**
 *   	
 *   	删除元素
 *   
 * ArrayList
 * 
 * @author wawjy
 *
 */
public class TestArrayList {
	public static void main(String[] args) {
		
		// ArrayList存储数据的对象
		ArrayList arrayList = new ArrayList();// size = 0 capacity 10   
		
		arrayList.addFirst(10);
		arrayList.addFirst(11);
		System.out.println(arrayList.toString());
		
		arrayList.addFirst(44);
		System.out.println(arrayList.toString());
		
		
		arrayList.addLast(33);
		System.out.println(arrayList.toString());
		arrayList.addLast(33);
		arrayList.addLast(33);
		arrayList.addLast(33);
		arrayList.addLast(33);
		arrayList.addLast(33);
		
		System.out.println(arrayList.toString());
		
		arrayList.addLast(44);
		System.out.println(arrayList.toString());
		
		arrayList.addLast(55);
		System.out.println(arrayList.toString());
		
		
		arrayList.remove(0);
		System.out.println(arrayList.toString());
		
		
		arrayList.addLast(55);
		System.out.println(arrayList.toString());
		
		arrayList.remove(0);
		System.out.println(arrayList.toString());
		
		arrayList.remove(0);
		arrayList.remove(0);
		arrayList.remove(0);
		arrayList.remove(0);
		arrayList.remove(0);
		System.out.println(arrayList.toString());
		arrayList.remove(0);
		System.out.println(arrayList.toString());
	}
}