折纸的不归路(8)

一,数组补充内容

package array;
import java.util.Arrays;
public class ArrayTest {
	static String[] strs = new String[5];//声明一个数组strs并初始化
	public static void main(String[] args) {
		int[] arr = new int[] {7,5,8,2};//声明一个数组arr并初始化
		System.out.println(arr);//输出arr数组的地址
		System.out.println(strs[2]);//输出strs数组的第三个元素
		System.out.println(arr[2]);//输出arr数组的第三个元素
		String str1 = new String("hello");//声明并定义一个字符串str1并赋值hello
		strs[0] = str1;//将str1的内容赋值给strs数组的第一个元素
		System.out.println(strs[0]);//输出strs数组的第一个元素
		System.out.println("==================");
		//遍历strs,以数组方式输出
		for(int i = 0;i<strs.length;i++) {
			if(i==0) {
				System.out.print("["+strs[0]+",");
			}else if(i==strs.length-1) {
				System.out.print(strs[i]+"]");
			}else {
				System.out.print(strs[i]+",");
			}	
		}	
		System.out.println("\t");
		System.out.println("==================");
		//遍历arr
		//先new一个对象
		ArrayTest at = new ArrayTest();
		//调用遍历的方法,传入想要遍历的数组
		at.showIntArray(arr);
		//使用jdk内置的数组打印方法,适合只查看数组内容
		String result = Arrays.toString(arr);
		System.out.println(result);
	}
	//自定义一个int数组的遍历方法
	public void showIntArray(int[] array) {
		for(int i = 0;i<array.length;i++) {
			if(i==0) {
				System.out.print("["+array[0]+", ");
			}else if(i==array.length-1) {
				System.out.print(array[i]+"]");
			}else {
				System.out.print(array[i]+", ");
			}	
		}	
	}
}

package array;

import java.util.Arrays;

public class ArrayTest2 {
	
	static int[] array = new int[] {2,4,6,8,1,3,5};//准备对象来调用成员方法
	//准备一个计数的变量size
	static int size;
	public static void main(String[] args) {
		//new一个对象命名为at2,用来调用ArratTest2中的方法
		ArrayTest2 at2 = new ArrayTest2();
		//new一个对象命名为at,用来调用ArratTest中的方法
		ArrayTest at = new ArrayTest();
		//判断原array和经过拷贝方法后的at2.copyArray(array)是否占用同一块内存
		//即是否经过复制生成新的数组
		if(array == at2.copyArray(array)) {
			System.out.println("地址相同,是同一块内存");
		}else {
			System.out.println("地址不同,不是同一块内存");
		}
		//用ArrayTest中的方法遍历ArrayTest2中拷贝生成的新数组
		at.showIntArray(at2.copyArray(array));
		System.out.println("\t");//换行
		System.out.println(array);//打印原数组array的地址
		System.out.println(at2.copyArray(array));//打印拷贝后的数组的地址
		System.out.println("================");
		//打印array的长度
		System.out.println(array.length);
		//打印array在extendArray方法执行后的长度
		//输入了一个数组,执行方法中的长度翻倍
		System.out.println(at2.extendArray(array).length);
		//打印array在extendArray方法执行后的长度
		//输入了一个数组和int类型的数字,执行把int数组扩容int数字个长度
		System.out.println(at2.extendArray(array,20).length);
		System.out.println("================");
		array = new int[5];//new一个新的数组,长度为5,并将array指向这个新数组
		//用for循环来向数组array中添加数
		for(int i=1;i<100;i++) {
			//执行add方法
			at2.add(i);
		}
		//用Arrays方法打印数组array
		System.out.println(Arrays.toString(array));
		System.out.println("==============================");
		//二维数组的遍历
		int [][] two = new int[3][3];
		for(int i=0;i<two.length;i++) {
			for(int j=0;j<two.length;j++) {
				System.out.print(two[i][j]+"\t");
			}
			System.out.println();
		}
	}
	//方法:数组的拷贝,以int数组为例
	//要求:传入一个数组,得到该数组的拷贝数组(两个数组的地址是不一样的)
	public int[] copyArray(int[] oldArray) {
		//第一步:声明并初始化一个新数组newArray并将oldArray的长度赋给newArray
		int[] newArray = new int[oldArray.length];
		//第二步:把oldArray里的每一项取出来对应的赋值给newArray里的每一项
		for(int i=0;i<oldArray.length;i++) {
			newArray[i] = oldArray[i];
		}
		return newArray;
	}
	//方法:数组的扩容
	//要求一:写一个方法,传入一个int数组,每执行一次,扩容一倍
	public int[] extendArray(int[] oldArray){
		//定义一个int型len,使它等与老数组的长度
		int len = oldArray.length;
		//将新数组的长度初始化为len的二倍,即扩容二倍
		int[] newArray = new int[len*2];
		//用for循环来将老数组的数据拷贝到扩容后的新数组中
		for(int i=0;i<oldArray.length;i++) {
			newArray[i] = oldArray[i];
		}
		return newArray;
	}
	//要求二:写一个方法,传入一个int数组和一个int数字,把int数组扩容int数字个长度
	public int[] extendArray(int[] oldArray,int count){
		//定义一个int型len,使它等与老数组的长度
		int len = oldArray.length;
		//将新数组的长度初始化为len+count,即扩容int数个
		int[] newArray = new int[len+count];
		//用for循环来将老数组的数据拷贝到扩容后的新数组中
		for(int i=0;i<oldArray.length;i++) {
			newArray[i] = oldArray[i];
		}
		return newArray;
	}
	//方法:需求:给at2声明一个add方法,无限向array中添加int数
		//应该先判断array是否已经满了
		//思路一:array是从空的开始添加
		//可以准备一个计数的变量size,每添加一次就记录一次,
		//当计数器等于array的初始化长度时,则证明满了
	//先声明一个add方法
	public void add(int i){
		//判断可计数变量size是否等于array的长度
		//如果等于,对array执行扩容方法,长度+1,并使array指向新地址
		if(size == array.length){
			array = extendArray(array,1);
		}
		//将新获得的i赋值给array的第size下标的元素,实现添加int数
		array[size] = i;
		size++;
	}
	//根据下标去删除
		//删除的时候先判断是否为最后一个元素,如果是直接变为0
		//如果不是最后一个元素,要注意把后面的元素向前移位
	public void remove(int index){	
	}
}

一,二维数组

可以理解为数组中保存了数组的类型

{{1,2,3},
{4,5,6},
{7,8,9}}

二维数组的定义方式

int[][] array;

二维数组初始化

new int[2][3];
new int[2][];
//可以不指定列,但是一定要指定行

访问

int[2][3] = 10;
int[0][0] = 1;

二维数组实例:
提供一个需求:
我们有一个三层楼的公寓,每一层三间房子,我们现在有六个学生,第一层住两个学生,这两个学生不想连着住,第二层住三个学生,第三层住一个学生,使用二维数组模拟一下住户图
先建立一个student类:

package com.briup.day06;
public class Student {
	//提供成员
	//属性 ---> 变量
	String name;
	int age;
	String gender;
	//第一次使用一下构造器
	public Student() {
		//如果一个类中没有定义任何的构造器
		//则默认提供一个没有参数的构造器
	}
	//给一个可以放名字的构造器
	public Student(String name) {
		this.name = name;
	}
	//全参构造器
	public Student(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	//方法
	public void study() {
	}
	public void show() {
	}
	//设置名字的方法
	public void setName(String newName) {
		name = newName;
	}
	//获取名字的方法
	public String getName() {
		return name;
	}
}

然后创建Test.java

package com.briup.day06;
public class Test {
	public static void main(String[] args) {
		Student[][] room = new Student[3][3];
		//Student的数组中保存的一定是Student的对象
		Student s1 = new Student("tom");
		Student s2 = new Student("jerry");
		Student s3 = new Student("ben");
		Student s4 = new Student("ken");
		Student s5 = new Student("lisa");
		Student s6 = new Student("ella");
		//分配房间
		room[0][0] = s1;
		room[0][2] = s2;
		room[1][0] = s3;
		room[1][1] = s4;
		room[1][2] = s5;
		room[2][0] = s6;
		//输出房间的分配图
		//如果有人居住,则输出名字
		//如果没有人居住,则输出无人居住
		for(int i=0;i<room.length;i++) {
			for(int j=0;j<room.length;j++) {
				//三目运算符的使用场景
				System.out.print((room[i][j]==null?"无人居住":room[i][j].getName())+"\t");
			}
			System.out.println();
		}
	}
}

运行出的结果为

tom	无人居住 jerry	
ben	ken	lisa	
ella 无人居住 无人居住

二,eclipse的使用

1.使用之前确保jdk是好的
2.eclipse放在非中文非c盘的路径下
3.准备一个你喜欢的找得到的英文路径,创建一个文件夹javacode,作为工作空间(workplace)
4.开始第一个java工程
new—>project—>java project
5.新建一个包
右键src—>new—>package,输入包名
6.在对应的包里新建类

三,排序问题

例子:
数组a [8,3,1,5,3,2,6];
升序数列:[1,2,3,3,5,6,8];
降序数列:[8,6,5,3,3,2,1];

冒泡排序

相邻的两个两个进行比较,根据大小位置交换位置,过程为:
[8,3,1,5,3,2,6]
//第一次循环
[3,8,1,5,3,2,6]
[3,1,8,5,3,2,6]
[3,1,5,8,3,2,6]
[3,1,5,3,8,2,6]
[3,1,5,3,2,8,6]
[3,1,5,3,2,6,8]
//第二次循环
[1,3,5,3,2,6,8]
[1,3,3,5,2,6,8]
[1,3,3,2,5,6,8]
//第三次循环
…
直到
[1,2,3,3,5,6,8]
数组中进行对比的下标的组合
0 1
1 2
2 3
3 4
4 5
5 6
用程序来实现:

for(int i=0;i<a.length-1;i++){
	for(int j=0;j<a.length-1-i){
		if(a[j]<a[j+1]){
			//交换位置(降序)
			//不使用第三方变量
			//1.+=
			a[j] = a[j]+a[j+1];
			a[j+1] = a[j] - a[j+1];
			a[j] = a[j] - a[j+1];
			//2.^
			a[j] = a[j]^a[j+1];
			a[j+1] = a[j]^a[j+1];
			a[j] = a[j]^a[j+1];
			//使用第三方变量
			int temp = a[j];
			a[j] = a[j+1];
			a[j+1] = temp;
		}
	}
}

实例:

package com.briup.test;
//冒泡排序
import java.util.Arrays;
//ctrl+shift+o:监测需要导入的包和删除未使用的包
public class SortTest {
	//定义两个常量
	static Boolean UP = true;
	static Boolean DOWN = false;
	public static void main(String[] args) {
		int[] array = new int[] {8,3,1,5,3,2,6};
		System.out.println("排序前:");
		System.out.println(Arrays.toString(array));
		//排序,以升序为例
	//	array = sort(array,UP);
	//	array = sort(array,DOWN);//如果是降序
		//jdk有提供的自然排序方法
	//	Arrays.sort(array);
		for(int i=0;i<array.length-1;i++){
			for(int j=0;j>array.length-1-i;j++) {//如果需要降序,将循环条件改为j<array.length-1-i
				if(array[j]<array[j+1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		System.out.println("排序后:");
		System.out.println(Arrays.toString(array));
	}
	//排序算法的封装
	public static int[] sort(int[] array,boolean flag) {
		//判断一下是升序还是降序
		if(flag) {
			for(int i=0;i<array.length-1;i++){
				for(int j=0;j<array.length-1-i;j++) {
					if(array[j]>array[j+1]) {
						int temp = array[j];
						array[j] = array[j+1];
						array[j+1] = temp;
					}
				}
			}
		}else {
			for(int i=0;i<array.length-1;i++){
				for(int j=0;j<array.length-1-i;j++) {
					if(array[j]<array[j+1]) {
						int temp = array[j];
						array[j] = array[j+1];
						array[j+1] = temp;
					}
				}
			}
		}
		return array;
	}
}

剩下还有快速排序,希尔排序,插入排序,选择排序,今天暂时没有涉及到.

四,OOP 面向对象编程

类和对象的关系
类是一个相同属性和行为的对象的集合,只是起描述作用
对象是一个类的实际表现
清楚一个类有哪些内容
public class 类名{
类中有哪些成员?
变量
方法:
修饰符:
返回值:
方法名:
参数列表:
抛出异常:throws
方法体:
构造器.一般类中准备一个无参构造器和全参构造器

五,用数组来模拟栈的数据结构

package com.briup.test;

package com.briup.test;
import sun.security.provider.certpath.IndexedCollectionCertStore;
//使用数组来模拟栈的数据结构
//先进后出
//添加元素从尾部开始添加
//删除元素从尾部开始删除
public class Stack {
	int[] data; //储存数据
	int size;//保存栈的实际长度
	//使用构造器做初始化
	public Stack() {
		data = new int[10];
	}
	public Stack(int length) {
		data = new int[length];
	}
	//入栈的方法
	public void in(int i) {
		//判断栈是否溢出
		if(size == data.length) {
			System.out.println("栈溢出,请检查");
		}
		data[size++] = i;
		//size++;
	}
	//出栈的方法
	public int out() {
		//判断栈是不是空了
		if (size == 0) {
			System.out.println("栈已空,无数据可出");
		}
		int temp = data[size-1];
		data[size-1] = 0;
		size--;
		return temp;
	}
	//修改栈内指定位置的元素
	public void change(int index,int number) {
		//判断index是否再size的范围
		if (index<size) {
			data[index] = number;
		}else {
			System.out.println("输入索引有误");
		}
		data[index] = number;
	}
	//获取栈的长度
	public int size() {
		return size;
	}
	//输出栈的内容
	public void show() {
		for(int i=0;i<size;i++) {
			System.out.println("当前栈中第"+(i+1)+"个元素是:"+data[i]);
		}
	}
}

六,心得

今天的内容感觉比昨天的要简单一些,接受起来相对比较容易,可能是因为之前没有学过数组的相关内容的原因,今天自习时间都用来回顾昨天的内容了,到现在还是有一些地方一知半解,得利用这个周末来好好理清一下数组的相关内容.今天是第一天开始使用工具,也是深深感受到了工具的强大,明天加油!