[JavaSE] 一维数组【排序】【查找】【复制】【扩容】【可变参数】—Day12

目录

一、数组的概念

1、简介

2、特性

3、特点

二、数组的作用                                                      

三、数组的声明                                                                              

四、数组的初始化   

  1.静态初始化：

  2.动态初始化：

五、数组的使用

六、数组的排序

冒泡排序

七、数组的查找

7.1.顺序查找：从头到尾遍历

 7.2.二分法查找（把排好序的数组一分为二的查找）             

八、扩展-数组的复制  

知识点：数组的复制1 

知识点：数组的复制2                                                                                                         

九、扩展-数组的扩容 

十、扩展-数组的删除       

十一、扩展-数组作为返回值和参数   

十二、扩展-可变参数             

    总结：

十三、Arrays工具类     

1、简介

数组（Array），在 Java 中也属于一种数据类型，区别于 int，String 之类的基本数据类型，数组是引用数据类型的一种。数组是有序数组的集合，里面的每个元素都必须具有相同的类型，可以用不同的数组名加上不同的下标来定位数组中唯一的元素。

2、特性

在大部分计算机语言中，数组基本上都具有一下三大基本特性：

（1）一致性：数组中存储的所有元素都必须是相同数据类型的。

（2）有序性：数组中的元素是有序的，可以通过数组下标来访问的。

（3）不可变性：数组一旦初始化，数组中的元素个数就不可变了。

3、特点

（1）数组可分为一维数组、二维数组以及多维数组。

（2）数组中数值元素的默认值是0，引用元素的默认值是null。

（3）数组的索引都是从0开始，如果数组内有n个元素，那么最大下标就是（n-1）。

（4）数组元素的类型可以是任何的数据类型，包括数组这一个复合数据类型。           

（5）数组初始化开辟的空间在内存中是连续的

（6）数组类型是从抽象类 Array 派生的引用类型。

 一组数据的容器，存放数据，并且 *** 作数据

//数据类型[] 数组名;  或  数据类型 数组名[];
       int[]  a;                int b[]; 

        程序员指定元素，系统自动分配长度 

//静态初始化1
//String[] names = new String[]{"朴树","肖战","杨洋","任嘉伦","郑业成"};
		
//静态初始化2(先声明，在初始化)
//String[] names;
//names = new String[]{"朴树","肖战","杨洋","任嘉伦","郑业成"};
		
//静态初始化3(简化静态初始化1)
String[] names = {"朴树","肖战","杨洋","任嘉伦","郑业成"};

        程序员指定长度，系统自动分配元素       

//动态初始化1：
String[] names = new String[5];//5 - 表示开辟5个连续的空间

       默认值：
            整数类型：0
            浮点类型：0.0
            字符类型：' '
            布尔类型：false
            引用类型：null(空) 

                                                                                                             
         静态初始化 vs 动态初始化
                一开始我们就知道数据，就使用静态初始化
                一开始我们就知道长度，就使用动态初始化

数组的使用包括：通过下标设置元素、获取元素，获取数组中元素个数和数组的遍历等等

//通过下标设置元素
names[2] = "鹿晗";
        
//通过下标获取元素
String n = names[2];
System.out.println("通过下标获取元素：" + n);//徐精华
        
//获取数组中元素的个数
int len = names.length;
System.out.println("获取数组中元素的个数：" + len);//5
        
System.out.println("-------------");
        
//遍历 - for循环
for(int i = 0;i

public class Test03{
	
	public static void main(String[] args){
	
		
		int[] is = {67,45,81,24,16};
	
		//冒泡排序
		for(int i = 0;i is[j+1]){
					int temp = is[j];
					is[j] = is[j+1];
					is[j+1] = temp;
				}
			}
		}
		
		//打印
		for(int element : is){
			System.out.println(element);
		}
	}
}

 int[] is = {67,45,81,24,16};
 int num = 81;//要查找的数据
 for(int element : is){
      if(element == num){
        System.out.println("查找到元素了");
       }
  }

int[] is = {67,45,81,24,16};
		
Arrays.sort(is);//排序
		
int num = 81;//要查找的数据
		
int start = 0;
int end = is.length-1;
		
while(start <= end){
	nt mid = (start + end)/2;
			
	if(is[mid] > num){
		end = mid-1;
	}else if(is[mid] < num){
		start = mid+1;
	}else{
		System.out.println("查找到元素了");
		break;
	}
}
		

		//原数组
		String[] names = {"朴树","肖战","杨洋","任嘉伦"};
		
		//新数组（将原数组中的对象地址赋值给新数组这个引用，names和newNames这两个引用是指向的同一个数组对象）
		String[] newNames = names;
		
		//改变原数组中的数据
		names[1] = "郑业成";
		
		//遍历新数组
		for(String element : newNames){
			System.out.println(element);
		}

		//原数组
		String[] names = {"朴树","肖战","杨洋","任嘉伦"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//遍历原数组，将原数组中的数据依次迁移到新数组中
		for(int i = 0;i

		//原数组
		String[] names = {"朴树","肖战","杨洋","任嘉伦"};
		
		//创建新数组（新数组长度是原数组长度的1.5倍）
		int capacity = names.length;//4
		int newCapacity = capacity + (capacity>>1);//6
		String[] newNames = new String[newCapacity];
		
		//将原数组的数据迁移到新数组中
		for(int i = 0;i

		//原数组
		String[] names = {"朴树","肖战","杨洋","任嘉伦"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//遍历原数组（ 把除了"任嘉伦"以外的数据迁移到新数组中）
		int index = 0;
		for(String element : names){
			if(!element.equals("任嘉伦")){
				newNames[index] = element;
				index++;
			}
		}
		
		//将新数组赋值给原数组
		names = newNames;
		
		//遍历原数组
		for(String element : names){
			System.out.println(element);
		}

/**
			知识点：数组的删除2
		*/

		//原数组
		String[] names = {"朴树","肖战","杨洋","任嘉伦"};
		
		//数据的迁移
		for(int i = 1;i

		int[] is = {67,45,81,24,16};
		
		int[] maxAndMin = getMaxAndMin(is);
		
		System.out.println("最大值为：" + maxAndMin[0]);
		System.out.println("最小值为：" + maxAndMin[1]);
	}
	
	public static int[] getMaxAndMin(int[] is){
		int max = is[0];
		int min = is[0];
		for(int i = 1;i is[i]){
				min = is[i];
			}
		}
		int[] maxAndMin = new int[]{max,min};
		return maxAndMin;

		int max = getMax(1,2,3,4);//传入的参数作为元素压入到数组中
		
		System.out.println("最大值为：" + max);
	}
	
	public static int getMax(int... is){
		if(is.length != 0){//判断调用该方法时是否传入参数
			int max = is[0];
			for(int i = 1;i

import java.util.Arrays;
public class Test14{
	
	public static void main(String... args){
		
		int[] is = {67,45,81,24,16};
		
		//排序 - 16,24,45,67,81
		Arrays.sort(is);
		
		//查找/搜索
		//如果key在数组中，就返回下标;否则，返回 -插入点-1
		int key = 51;
		int index = Arrays.binarySearch(is,key);
		System.out.println("查询到元素的下标为：" + index);//-4
		
		//替换
		Arrays.fill(is,888);
		
		//局部替换
		Arrays.fill(is,1,3,666);//fill(目标数组,开始下标-包含,结束下标-不包含,要替换的值)
		
		//扩容
		int[] copyOf = Arrays.copyOf(is,is.length*2);//copyOf(目标数组,新的长度)
		
		//局部拷贝
		int[] copyOfRange = Arrays.copyOfRange(copyOf,2,5);copyOfRange(目标数组,开始下标-包含,结束下标-不包含)
		
		//将数组转换为字符串
		String str = Arrays.toString(copyOfRange);
		System.out.println(str);

	}
	
}