前段时间一直忙着毕业设计，很久没有复习一些编程基础。即将毕业，趁着还有充足的时间，现在每天都在复习以及学习新的知识。前几天复习的是Java 中array的知识，正好趁着记忆有点模糊，来总结一下。PS 前几天学习的新东西是使用SpringBoot搭建个人博客，总的来说自己看着别人的源码，照着学习，还是学到了很多知识，但是因为找的学习资源不充分，因此博客项目的学习最后还是草草收工，代码已经上传到我的Github仓库了，有需要的小伙伴可以去下载看看。至少是可以从中学到很多知识，比如 权限管理的拦截器，前后端的连接调通，Mybatis知识的复习等等，非常多。
我新创建的一个专门复习的Java工程，也上传到了我的Github仓库没有需要的小伙伴们可以自行下载代码。
Fighting_Boss_Hao 的Github仓库
对此次复习的知识，数组部分的代码目录如下
首先是手写一个 通过索引操作无序数组
public class OperateWithIndex {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateWithIndex(int length) {
datas = new int[length];
}
public int insert(int data) {
datas[currentIndex] = data;
currentIndex++;
return currentIndex - 1;//这里是返回自增之前的添加索引
}
//删除就是从index开始，所有元素向后移一位
public void remove(int index) {
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
}
public int searchOne(int index) {
return datas[index];
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateWithIndex op = new OperateWithIndex(20);
op.insert(1);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(6);
op.insert(7);
op.printDatas();
op.remove(3);
op.printDatas();
int result = op.searchOne(3);
System.out.println("result : " + result);
}
}接下来 逐步演进， 第二个 是演示操作直接使用数据操作无无序数组,存放不重复的值
第二种 通过直接使用数据来操作无序数组，相比于第一种差别就是 它操作的是数据。多加的操作就是执行操作前先找到数据的索引，然后再进一步操作。
public class OperateNoIndex {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateNoIndex(int length) {
datas = new int[length];
}
public int insert(int data) {
datas[currentIndex] = data;
currentIndex++;
return currentIndex - 1;
}
public int getIndex(int data) {
int index = -1;
for (int j = 0; j < currentIndex; j++) {
if (datas[j] == data) {
index = j;
break;
}
}
return index;
}
public void remove(int data) {
//1.查找这个数据对应的索引
int index = getIndex(data);
//2.同使用索引的而方法，由索引删除数据
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
}
public int searchOne(int data) {
//1.查找这个数据对应的索引
int index = getIndex(data);
//2.如果有，就返回datas中的数据
if (index >=0) {
return datas[index];
}
//3.如果没有，就返回0;
return 0;
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateNoIndex op = new OperateNoIndex(20);
op.insert(1);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(7);
op.printDatas();
op.remove(3);
op.printDatas();
int result = op.searchOne(3);
System.out.println("result : " + result);
}
}
第三种 演示操作直接使用数据操作无无序数组,* 存放重复的值
第三种相较于第二种，主要是可以存放重复的值，需要多做的操作就是对操做的结果要循环的执行，找出所有的结果。
public class OperateNoIndexRepetable {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateNoIndexRepetable(int length) {
datas = new int[length];
}
public int insert(int data) {
datas[currentIndex] = data;
currentIndex++;
return currentIndex - 1;
}
/**
*获取数据data在数组中的索引位置
* begin 开始查找的位置
* data 查找索引的数据
* return 从开始位置往后的第一个索引
*/
public int getIndex(int begin,int data) {
int index = -1;
for (int j = begin; j < currentIndex; j++) {
if (datas[j] == data) {
index = j;
break;
}
}
return index;
}
public void remove(int data) {
//1.查找这个数据对应的索引
int index = getIndex(0,data);
//循环向后查找这个索引，直到找不到为止
while(index>=0){
//2.同使用索引的而方法，由索引删除数据 这里要注意的是 这个循环是从尾部开始，为前边
// index对应的data让出位置，依次向后移动
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
//再次查找后续的数据对应的索引
index= getIndex(index,data);
}
}
public List<Integer> searchOne(int data) {
List<Integer> reList = new ArrayList<>();
//1.查找这个数据对应的索引
int index = getIndex(0,data);
while(index>=0){
//2.如果有，就添加到要返回的集合中
reList.add(datas[index]);
//再次查找后续的数据对应的索引
index= getIndex(index+1,data);
}
return reList;
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateNoIndexRepetable op = new OperateNoIndexRepetable(20);
op.insert(1);
op.insert(3);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(6);
op.insert(7);
op.printDatas();
op.remove(3);
op.printDatas();
List<Integer> result = op.searchOne(6);
System.out.println("result : " + result);
}
}
第四种 是演示操作直接使用数据操作有序数组,存放不重复的值
第四种操作的是有序数组，因此对于数据的插入操作需要先进行排序。对于删除和查找则是循环的比较
public class OperateOrderNoIndex {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateOrderNoIndex(int length) {
datas = new int[length];
}
public int insert(int data) {
//假设顺序是升序
int index =0;
//1.查找数据data应该存放的位置
for (index=0;index<currentIndex;index++){
if(datas[index]>data){
break;
}
}
//2.把这个位置及其后面的数据，向后移动一位
for (int i =currentIndex;i>index;i--){
datas[i]=datas[i-1];
}
//3.把data设置到应该存放的位置
datas[index] = data;
currentIndex++;
return currentIndex -1;//返回自增前的地址
}
public int getIndex(int data) {
int index = -1;
for (int j = 0; j < currentIndex; j++) {
if (datas[j] == data) {
index = j;
break;
}
}
return index;
}
public void remove(int data) {
//1.查找这个数据对应的索引
int index = getIndex(data);
//2.同使用索引的而方法，由索引删除数据
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
}
public int searchOne(int data) {
//1.查找这个数据对应的索引
int index = getIndex(data);
//2.如果有，就返回datas中的数据
if (index >=0) {
return datas[index];
}
//3.如果没有，就返回0;
return 0;
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateOrderNoIndex op = new OperateOrderNoIndex(20);
op.insert(1);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(7);
op.printDatas();
op.remove(3);
op.printDatas();
int result = op.searchOne(3);
System.out.println("result : " + result);
}
}
第五种 是 演示操作直接使用数据操作有序数组,* 存放重复的值
重点就是 有序数组，重复的值
此方法，和第四种几乎没变
public class OperateOrderNoIndexRepetable {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateOrderNoIndexRepetable(int length) {
datas = new int[length];
}
public int insert(int data) {
//假设顺序是升序
int index =0;
//1.查找数据data应该存放的位置
for (index=0;index<currentIndex;index++){
if(datas[index]>data){
break;
}
}
//2.把这个位置及其后面的数据，向后移动一位
for (int i =currentIndex;i>index;i--){
datas[i]=datas[i-1];
}
//3.把data设置到应该存放的位置
datas[index] = data;
currentIndex++;
return currentIndex -1;//返回自增前的地址
}
/**
*获取数据data在数组中的索引位置
* begin 开始查找的位置
* data 查找索引的数据
* return 从开始位置往后的第一个索引
*/
public int getIndex(int begin,int data) {
int index = -1;
for (int j = begin; j < currentIndex; j++) {
if (datas[j] == data) {
index = j;
break;
}
}
return index;
}
public void remove(int data) {
//1.查找这个数据对应的索引
int index = getIndex(0,data);
//循环向后查找这个方法，直到找不到为止
while(index>=0){
//2.同使用索引的方法，由索引删除数据
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
//再次查找后续的数据对应的索引
index= getIndex(index,data);
}
}
public List<Integer> searchOne(int data) {
List<Integer> reList = new ArrayList<>();
//1.查找这个数据对应的索引
int index = getIndex(0,data);
while(index>=0){
//2.如果有，就添加到要返回的集合中
reList.add(datas[index]);
//再次查找后续的数据对应的索引
index= getIndex(index+1,data);
}
return reList;
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateOrderNoIndexRepetable op = new OperateOrderNoIndexRepetable(20);
op.insert(1);
op.insert(3);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(6);
op.insert(7);
op.printDatas();
op.remove(3);
op.printDatas();
List<Integer> result = op.searchOne(6);
System.out.println("result : " + result);
}
}
第六种 将操作对象换成 Object
1.先创建一个Model ,排序用到的是其属性UUID
2.将对象换到代码中去
public class UserModel1 {
private int uuid;
private String name;
private int age;
public UserModel1(int uuid, String name, int age) {
this.uuid = uuid;
this.name = name;
this.age = age;
}
public int getUuid() {
return uuid;
}
public void setUuid(int uuid) {
this.uuid = uuid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "UserModel1{" +
"uuid=" + uuid +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class OperateOrderNoIndexObject {
private UserModel1[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateOrderNoIndexObject(int length) {
datas = new UserModel1[length];
}
public int insert(UserModel1 data) {
//假设顺序是升序
int index = 0;
//1.查找数据data应该存放的位置
for (index = 0; index < currentIndex; index++) {
if (datas[index].getUuid() > data.getUuid()) {
break;
}
}
//2.把这个位置及其后面的数据，向后移动一位
for (int i = currentIndex; i > index; i--) {
datas[i] = datas[i - 1];
}
//3.把data设置到应该存放的位置
datas[index] = data;
currentIndex++;
return currentIndex - 1;//返回自增前的地址
}
public int getIndex(int uuid) {
int index = -1;
for (int j = 0; j < currentIndex; j++) {
if (datas[j].getUuid() == uuid) {
index = j;
break;
}
}
return index;
}
public void remove(int uuid) {
//1.查找这个数据对应的索引
int index = getIndex(uuid);
//2.同使用索引的而方法，由索引删除数据
for (int i = index; i < currentIndex; i++) {
datas[i] = datas[i + 1];
}
currentIndex--;
}
public UserModel1 searchOne(int uuid) {
//1.查找这个数据对应的索引
int index = getIndex(uuid);
//2.如果有，就返回datas中的数据
if (index >= 0) {
return datas[index];
}
//3.如果没有，就返回null;
return null;
}
public void printDatas() {
System.out.println("==================");
for (UserModel1 d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateOrderNoIndexObject op = new OperateOrderNoIndexObject(10);
op.insert(new UserModel1(1,"张三",6));
op.insert(new UserModel1(2,"haha",7));
op.insert(new UserModel1(3,"李四",6));
op.insert(new UserModel1(6,"呱呱",5));
op.insert(new UserModel1(7,"唧唧",3));
op.insert(new UserModel1(4,"啦啦",16));
op.remove(3);
op.printDatas();
UserModel1 model1 = op.searchOne(4);
System.out.println("result : " + model1);
}
}
最后可以利用第五重数据的代码，稍加修改写一个二分查找算法
public class OperateOrderNoIndexBinarySearch {
private int[] datas = null;//定义数据
private int currentIndex = 0;//定义索引
public OperateOrderNoIndexBinarySearch(int length) {
datas = new int[length];
}
public int insert(int data) {
//假设顺序是升序
int index =0;
//1.查找数据data应该存放的位置。
for (index=0;index<currentIndex;index++){
if(datas[index]>data){
break;
}
}
//2.把这个位置及其后面的数据，向后移动一位。
for (int i =currentIndex;i>index;i--){
datas[i]=datas[i-1];
}
//3.把data设置到应该存放的位置。
datas[index] = data;
currentIndex++;
return currentIndex -1;//返回自增前的地址
}
public int binarySearch(int data) {
int index = -1;
//用来表示小的这边的索引
int lowIndex=0;
//用来表示大的这边的索引
int highIndex=currentIndex-1;//因为插入的时候最后的索引是++
while(true){
//1.找到中间的位置
index= ( lowIndex + highIndex )/2;
//2.把要查找的数据和中间索引位置的数据进行比较
if(lowIndex>highIndex){
//没找到数据
return -1;
}else if(datas[index]==data){
return index;
}else{
if (data<datas[index]) {
highIndex = index-1;
}else{
lowIndex = index +1;
}
}
}
}
public void printDatas() {
System.out.println("==================");
for (int d : datas) {
System.out.println(d);
}
}
public static void main(String args[]) {
OperateOrderNoIndexBinarySearch op = new OperateOrderNoIndexBinarySearch(20);
op.insert(1);
op.insert(3);
op.insert(4);
op.insert(6);
op.insert(7);
op.printDatas();
int i = op.binarySearch(4);
System.out.println("result index is :"+ i);
}
}
哦了，过了一遍代码，又复习了一遍。对于所实现的数据，仅仅是简单的实现，并没有考虑一下边界值等。 接下来该复习今天的知识，以及学习新的知识。
434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
