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