目录
前言
概念：指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作，它是典型的线性结构。
一、数组的基本使用
1、数组的创建
package demo1
public class TestArray{
public static void main(String[] args){
//创建一个数组
int[] arr1 = new int[3];
//获取数组长度
int length1 = arr1.length;
System.out.println("数组的长度是："+length1);
//访问数组中的元素：数组名[下标] 注意：下标从0开始，最大可以取到长度-1
int element0 = arr1[0];
System.out.println("数组的第一个值："+element0);
//为数组中的元素赋值
arr1[0]=99;
System.out.println("给数组第一个值赋值"+arr1[0]);
arr1[1]=98;
arr1[2]=97;
//遍历数组
for(int i=0;i<length1;i++){
System.out.println("数组的第"+i+"元素是："+arr1[i]);
}
//创建数组的同时为数组中的元素赋值
int[] arr2 = new int[] {90,80,70,60,50};
//获取数组的长度
System.out.print("数组的长度："+arr2.length);
}
}2、数组元素的添加
（1）、解决数组的长度不可变的问题
思路：
·创建一个新的数组，长度是原数组长度+1
·把原数组中的数据全部复制到新数组中
·把目标元素放到新数组的最后
·新数组替换原数组
package demo1
public class TestOpArray{
public static void main(String[] args){
//解决数组的长度不可变的问题
int[] arr = new int[] {9,8,7};
//快速查看数组中的元素
System.out.println(Arrays.toString(arr));
//要加入数组的目标元素
int dst = 6;
//创建一个新的数组，长度是原数组长度+1
int[] newArr = new int[arr.length+1];
//把原数组中的数据全部复制到新数组中
for(int i=0;i<arr.length;i++){
newArr[i] = arr[i];
}
//把目标元素放到新数组的最后
newArr[arr.length]=dst;
//新数组替换原数组
arr=newArr;
System.out.println(Arrays.toString(arr));
}
}3、数组的删除
思路：
创建一个新的数组长度是原数组的长度-1
复制原数组中除了要删除的那个元素以外的其他的元素
要删除的元素之前的元素
要删除的元素之后的元素
新数组替换旧数组
package demo1
public class TestOpArray2{
//如何删除数组中的元素
public static void main(String[] args){
//目标数组
int[] arr = new int[] {9,8,7,6,5,4};
//要删除的元素的下标
int dst = 3;
//创建一个新的数组长度是原数组的长度-1
int[] newArr = new int[arr.length-1];
//复制原数组中除了要删除的那个元素以外的其他的元素
for(int i=0;i<newArr.length;i++){
//要删除的元素之前的元素
if(i<dst){
newArr[i]=arr[i];
//要删除的元素之后的元素
}else{
newArr[i]=arr[i+1];
}}
//新数组替换旧数组
arr=newArr;
System.out.println(Arrays.toString(arr));
}
}
二、面向对象的数组
什么是对象：能看到的或者说在程序中可以直接使用的内容称为对象
通过new关键字创建的：类名 对象名=new 类名();
面向对象数组概念：对象数组就是数组里的每个元素都是类的对象，赋值时先定义对象，然后将对象直接赋给数组就行了。
这个圆就是一个对象，里面有数组，还有操作数组的方法。
下面举例说明：
首先创建一个对象：
package demo1.util
public class MyArray{
//用于存储int类型数据的数组
private int[] elements;
public MyArray(){
elements = new int[0];
}
//获取数组长度的方法
public int size(){
return elements.length;
}
//往数组的末尾添加一个元素
public void add(int element){
//创建一个新的数组
int[] newArr = new int[elements.length+1];
//把原数组中的元素复制到新数组中
for(int i=0;i<elements.length;i++){
newArr[i]=elemnts[i];
}
//把添加的元素放入新数组中
newArr[elements.length]=element;
//使用新数组替换旧数组
elements = newArr;
}
//打印所有元素到控制台
public void show(){
System.out.println(Arrays.toString(elements));
}
//删除数组中的元素
public void delete(int index){
//判断下标是否越界
if(index<0 || index>elements.length-1){
throw new RuntimeException("下标越界");
}
//创建一个新的数组，长度为原数组的长度-1
int[] newArr = new int[elements.length-1];
//赋值原有数组的新数组
for(int i=0;i<newArr.length;i++){
//想要删除的元素前面的元素
if(i<index){
newArr[i] = elements[i];
//想要删除的元素后面的元素
}else{
newArr[i]=elements[i+1];
}
}
//新数组替换旧数组
elements=newArr;
}
//获取指定位置元素
public void get(int index){
//判断位置是否合法
if(index<0 || index>elements.length-1){
throw new RuntimeException("下标越界");
}
return elements[index];
}
//插入一个元素到指定位置
punlic void insert(int index,int element){
//创建一个新的数组
int[] newArr = new int[elemnts.length+1];
//将原数组中的元素放入新数组中
for(int i=0;i<elements.length;i++){
//目标位置之前的元素
if(i<index){
newArr[i] = elements[i];
}else{
newArr[i+1] = elements[i];
}
}
//插入新的元素
newArr[index] = element;
//新数组替换旧数组
elements=newArr;
}
//替换指定位置的元素
public void set(int index,int element){
//判断位置是否合法
if(index<0 || index>elements.length-1){
throw new RuntimeException("下标越界");
}
elements[index] = element;
}
//线性查找
public int search(int target){
//遍历数组
for(int i=0;i<elements.length;i++){
if(elements[i]==target){
return i;
}
}
return -1;
}
//二分法查找
public int binarySearch(int target){
//记录开始位置
int begin=0;
//记录结束位置
int end = elements.length-1;
//记录中间的位置
int mid =(begin+end)/2;
//记录目标位置
int index=-1;
//循环查找
while(true){
//什么情况下没有这个元素？
//如果开始位置在结束位置之后或重合。
if(begin>=end){
return = -1;
}
//判断中间的这个元素是不是要查找的元素
if(elements[mid]==target){
return mid;
//中间这个元素不是要查的元素
}else{
//判断中间这个元素是不是比目标元素大
if(elements[mid]>target){
//把结束位置调整到中间位置前一个位置
end=mid-1;
//中间这个元素比目标元素小
}else{
//把开始位置调整到中间位置的后一个位置
begin=mid+1;
}
//取出新的中间位置
mid=(begin+end)/2;
}
}
}
}
新创建一个类用于测试：
package demo1
import demo1.util.MyArray;
public class TestMyArray{
public static void main(String[] args){
//创建一个可变的数组
MyArray ma = new MyArray();
//获取长度
int size = ma.size();
System.out.println(size) //0
//添加元素之前调用show方法，数组是空输出[]
ma.show();
//往可变数组中添加一个元素
ma.add(99);
System.out.println(size) //添加完变成1
//添加元素后调用show方法，数组是[99]
ma.show();
ma.add(97);
ma.add(98);
//删除某个元素
ma.delete(1);
ma.show();
//获取某个位置的元素
System.out.println(ma.get(1))
//插入元素到指定位置
ma.add(96);
ma.add(95);
ma.add(94);
ma.show();
ma.insert(3,33);
ma.show();
//替换指定位置的元素
ma.set(0,100);
ma.show();
//线性查找
System.out.println("index："+ma.search(97));
//二分法查找
System.out.println("index："+ma.binarySearch(97));
}
}三、查找算法
1、线性查找
从数组的第0个开始，依次循环取值，与需要查找的值对比，知道找到为止，效率较低。
package demo1
public class TestSearch{
public static void main(String[] args){
//目标数组
int[] arr = new int[] {2,3,5,6,7,4,2,10};
//目标元素
int target=10;
//目标元素所在的下标
int index=-1;
//遍历数组
for(int i=0;i<arr.length;i++){
if(arr[i]==target){
index=i;
break;
}
}
//打印目标元素的下标
System.out.println("index"+index);
}
}2、二分法查找
二分法查找：很好理解，就是中间分隔，判断在哪一边。在分隔两份，然后判断在哪一面，依次分隔。但是缺陷是，查找的数组要是有序的。
package demo1
public class TestSearch{
public static void main(String[] args){
//目标数组
int[] arr = new int[] {1,2,3,4,5,6,7,8,9};
//目标元素
int target=8;
//记录开始位置
int begin=0;
//记录结束位置
int end = arr.length-1;
//记录中间的位置
int mid =(begin+end)/2;
//记录目标位置
int index=-1;
//循环查找
while(true){
//判断中间的这个元素是不是要查找的元素
if(arr[mid]==target){
index=mid;
break;
//中间这个元素不是要查的元素
}else{
//判断中间这个元素是不是比目标元素大
if(arr[mid]>target){
//把结束位置调整到中间位置前一个位置
end=mid-1;
//中间这个元素比目标元素小
}else{
//把开始位置调整到中间位置的后一个位置
begin=mid+1;
}
//取出新的中间位置
mid=(begin+end)/2
}
}
System.out.println("index:"+index)
}
}
扫一扫
550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
