菜鸡自学JAVA坎坷路day.12(StringBuilder,MyArrayList,多维数组，冒泡排序，File的简单操作，打印文件的树状结构)

本文链接：https://blog.youkuaiyun.com/qq_38053395/article/details/80374912

本文深入探讨了Java中的StringBuilder与StringBuffer的使用场景及区别，并详细介绍了自定义ArrayList的实现过程，同时还涉及多维数组操作、冒泡排序算法及File类的基本应用。

1.StringBuilder，StringBuffer

package testStringBuilder;
/**
 * 测试可变字符序列   StringBuilder（线程不安全，效率高） 	StingBuffer（线程安全，效率低）他们可变是因为前面没有加final修饰   【两者除了这一点区别别的基本一样】   我们一般用前者
 * String  不可变字符序列
 * @author Wang
 *
 */

public class test01 {
	public static void main(String[] args) {
		
		StringBuilder sb = new StringBuilder();  //默认初始化的字符数组长度是16
		StringBuilder sb1 = new StringBuilder(32);  //字符数组长度改为32  //注意这些功能都是根据JDK源码实现的可以查看源码了解具体的方法
		StringBuilder sb2 = new StringBuilder("abcd"); //value[] = {a','b','c','d',\u0000（因为数组是char类型的所以初始化为\u0000）,\u0000...}  长度为4 + 16
		
		sb2.append("efg");//把efg添加到  abcd的后面
		sb2.append(true).append(321).append("随便");   //通过append方法里的return this实现方法链.
		
		System.out.println(sb2);
		
		System.out.println("**********************");
		
		StringBuilder gh = new StringBuilder("a");//在这里容量只有17   但是如果容量不够的话  他会再建一个新的数组(17*2+2)  把原来数组里的内容拷贝过来  在不够就在执行一次  一直到够你用为止（扩容）；
		for (int i = 0; i < 20; i++) {
			gh.append(i);
		}//这次一共只有两个对象   就是new一个gh  和new前面生成的“a”；
		System.out.println(gh);
		
		StringBuilder sb3 = new StringBuilder("abcdefghijklmnopqrstuvwxyz");
		sb3.delete(3, 5);   //结果：abchijklmnopqrstuvwxyz   //包头不包尾；删除3  4不删除5
		System.out.println(sb3);
		sb3.reverse();//反转
		System.out.println(sb3);
		
		StringBuffer sb4 = new StringBuffer();//就是线程安全效率低其余的全一样
	
	}
}

2.模拟容器ArrayList写成的MyArrayList

package MyarrayList;

public class Human {
	private String name;
	
	public Human(String name) {
		this.name = name;
	}
	
	public String getName() {
		return this.name;
	}
}

package MyarrayList;
/**
 * 模拟实现JDK容器之一ArrayList的作用
 * 根据StringBuilder来写
 * @author Wang
 *
 */

public class MyArrayList {
	private Object[] value;//先创建一个Object类  类型的数组    注意类的首字母是大写的   “O”  变量的类型是小写
	private int size; //定义一个变量来表示数组的长度
	
	
	public MyArrayList() {//先写一个无参构造器
		this(10);//这里就会调用有一个参数的构造器将数组长度设置为10   所以你调用无参构造器的时候生成的数组长度是10
	}
	
	
	public MyArrayList(int size) {//定义一个确定数组长度的构造器
		if(size<0) {//如果你的size小于0了  那就抛出一个异常
			try {
				throw new Exception();  //手动抛出一个异常。 等更新到异常的时候在说；
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		value = new Object[size];
	}
	
	
	public int getSize () {//得到容器的长度
		return size;
	}
	
	
	public boolean isEmpty() {//判断容器是否为空
		return size == 0;//这句稍微注意一下很简洁
	}
	
	
	public void add(Object obj) {//往容器里面添加东西
		value[size] =  obj;
		size++;//添加进去一个东西索引就加一；
		if(size >= value.length) {
			int newSize = size * 2 + 2;//扩容
			Object[] newValue = new Object[newSize];//建立一个新的数组
			
			for(int i=0; i<value.length; i ++) {//把原来的东西放到新的里面
				newValue[i] = value[i]; 
			}
			
			value = newValue;//把新的扩容后的容器在给value
			
		}
	} 
	
	
	public void checkIndex(int index) {//检查你输入的索引符不符合规则
		if(index<0||index>size - 1) {
			try {
				throw new Exception();  //手动抛出一个异常。 
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public void replace(int index,Object obj) {//替换容器内的一个
		checkIndex(index);
		value[index] = obj;
	}
	
	
	public int indexOf(Object obj) {//从前往后查找对象obj的位置返回他的索引  未查找到则返回-1
		if(obj == null) {
			return -1;
		}else {
			for(int i=0;i<value.length;i++) {
				if(obj == value[i]) {
					return i;
				}
			}
		}
		return -1;
	}
	
	
	public int lastIndexOf(Object obj) {//从后往前查找对象obj的位置返回他的索引  未查找到则返回-1
		if(obj == null) {
			return -1;
		}else {
			for(int i=value.length;i>=0;i--) {
				if(obj == value[i]) {
					return i;
				}
			}
		}
		return -1;
	}
	
	
	public Object getSubstance(int index) {
		checkIndex(index);
		return value[index];
	}
	
	
	public static void main(String[] args) {
		MyArrayList  list = new MyArrayList(2);//创建一个容积为2的容器
		list.add("aaa");
		list.add(new Human("wang"));
		list.add("bbbb");//这里就是第三个了  空间不够了就会扩容
		list.add("bbbb");
		list.add("bbbb");
		list.add("bbbb");
		
		Human h = (Human) list.getSubstance(1);
		System.out.println(h.getName());
		
		System.out.println(list.getSize());
		
	}
	
}

注意：我们用的方法全指JDK里面的源码实现的所以我们要多看源码；

3.多维数组:

package TestArray;
/**
 * 二维数组的创建
 * @author Wang
 *
 */

public class Test{
	public static void main(String[] args) {
//		int [][] a = {
//		{1,2},
//		{3,4,0,9},
//		{5,6,7}
//	};

		int[][]  a = new int[3][];
		a[0] = new int[2];
		a[1] = new int[4];
		a[2] = new int[3];
		a[0][0] = 1;
		a[0][1] = 2;
		a[1][0] = 3;
		a[1][1] = 4;
		a[1][2] = 0;
		a[1][3] = 9;

		a[2][0] = 5;
		a[2][1] = 6;
		a[2][2] = 7;

		System.out.println(a[2][2]);
	}
}

package TestArray;
/**
 * 写一个方阵的加法     
 * @author Wang
 *
 */

public class Matrix {
	public static void main(String[] args) {
		int[][]  a = {
				{1,3,1},
				{2,4,2},
				{6,4,2}
			 };
		int[][]  b = {
				{3,3,4},
				{2,4,4},
				{1,4,5}
					  };
		
		int[][] c = addMatrix(a,b);
		matrixPrint(c);
		
	}
	
	
	public static void matrixPrint(int[][]a) {//打印一个矩阵
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a.length;j++) {
				System.out.print(a[i][j] + "  ");
			}
			System.out.println();
		}
	}
	
	
	public static int[][] addMatrix(int[][]a,int[][]b) {//两个方阵的加法
		int[][] c = new int[a.length][b.length];
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a.length;j++) {
				c[i][j] = a[i][j] + b[i][j];
			}
		}
		return c;
	}

}

注意：在Java中已经没有指针的概念了，Java引用的概念跟指针很像

4.BubbleSort and for-each的用法：

/**
 * 写一个冒泡排序
 * 
 * @author  Wang
 *
 */
public class BubbleSort {
	public static void main(String[] args) {
		int[] a = {1,4,6,9,8,5,2,2,3};
		bubbleSort(a);
		for(int m : a) {//这个是for each 的用法；
			System.out.print(m + " ");
		}
	}
	
	
	public static void bubbleSort(int[] a ) {//冒泡排序  把第一次比较是把最大的那个数字放到数组的最后面  在后来的比较中你就不需要比较后面的那个了
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<a.length-i-1;j++) {
				if(a[j]>a[j+1]) {
					int t;
					t = a[j];
					a[j] = a[j+1];
					a[j+1] = t;
				}
			}
		}
	}
	
	
	
	
}

5.File类一些简单的操作：

package MyFile;

import java.io.File;
import java.io.IOException;

/**
 * 测试file类的常用方法
 * @author Wang
 *
 */

public class testFile {
	public static void main(String[] args) throws IOException {
		File f = new File("D:/test/source/12.txt");//将F指向test这个文件夹  分隔符用这个\的时候要用两个一个是转义字符
		File f2 = new File("d:\\test\\source");
		File F3 = new File(f2,"123.txt");
		
		File f4 = new File(f2,"11.java");
		File f5 = new File("d:/test/aa/bb");
		
		//f5.mkdir();//他是每次只能建立一个文件夹  当你要求他一次建立一次建立多个文件的时候  他就不会进行操作了
		f5.mkdirs();//这个可以一次建立多个文件；
		
		f4.createNewFile();//这里要抛出异常才能建一个文件
		f4.delete();//删除
		
		if(f.isFile()){//判断f是不是一个文件
			System.out.println("是一个文件");
		}
		if(f2.isDirectory()){//判断f2是不是一个文件夹
			System.out.println("是一个目录");
		}
		
		
	}
}

6.打印一下文件的树状结构：

package testFile;

import java.io.File;

/**
 * 打印一下文件的树状结构
 * @author Wang
 *
 */

public class fileTree {
	public static void main(String[] args) {
		File f = new File("d:/360bizhi");
		printFile(f,0);
	}
	
	public static void printFile(File file,int level) {
		for(int i=0; i<level; i++) {
			System.out.print("-");
		}
		System.out.println(file.getName());
		
		if(file.isDirectory()) {//判断是不是文件夹
			File[]  files = file.listFiles();
			for(File temp : files) {
				printFile(temp, level+1);//递归自己调用自己
			}
		}
	}
}