1.数组的概念
1.1数组的定义
基本格式
数据类型[] 数组名 = new 数据类型[容量
2.数组的声明与赋值
赋值左侧
数据类型:
告知编译器,当前数组中能保存的数据类型到底是什么?并且在确定数据类型之后,整个数组中保存的数据类型无法更改
[]:
1.告知编译器这里定义的是一个数组类型数据
2.告知编译器,数组是一个【引用数据类型】
数组名:
1.操作数据非常重要的数据
2.数组是一个【引用数据类型】
赋值号右侧:
new:
申请【XX】内存空间,并且清空整个内存空间中所有二进制位,所有的二进制位都是0
数据类型:
前后呼应,告知编译器这里支持的存储的数据到底是什么
[容量]:
容量==>capacity
代码
int [] arr= new int [10];
3.数组的下标
数组中的下标是从0开始;到数组的容量-1
例如: 数组容量为10。有效下标范围为0-9
超出有效下标范围,都是无效下标。
容易出现的问题
1.数组下标越界:
ArrayIndexOutOfBoundsException
package day04;
public class Demo1 {
public static void main(String[] args) {
//定义一个int类型的数组
int [] arr= new int [10];
//首先赋值数组中下标位0的元素
arr[0]=10;
arr[2]=20;
//可以取值也可以赋值
System.out.println(arr[0]);
System.out.println(arr[2]);
}
}
堆区和栈区区别
堆区可以由程序员分配,栈区只能有系统分配。
引用数据类型是什么
开发中引用数据类型,用于保存其他 内存空间的首地址,保存地址后,cpu可以通过对应的引用数据类型,得到对应的地址,从而访问对应的内存空间
数组和循环之间的联系
获取数组容量的方式:数组名.length 属性 当前的数组属性length是要占用一定的数组空间的,属于数组中的内容。
package day04;
public class Demo2 {
public static void main(String[] args) {
int arr[] = new int [10];
//使用for循环对数组每一个进行赋值
for(int i =0;i<arr.length;i++){
arr[i] = i+1;
}
//使用for循环对数组中元素进行取值展示
for(int i =0;i<arr.length;i++){
System.out.println("arr"+"["+i+"]"+arr[i]);
}
}
}
数组和方法之间的关系
java中如何让数组成为方法的参数,已经使用使用方式
package day04;
public class Demo3 {
public static void main(String[] args) {
int arr[]=new int[10];
m1(arr);
m2(arr);
}
public static void m1(int[] arr){
for(int i =0;i<arr.length;i++){
arr[i] = i+1;
}
}
public static void m2(int[] arr){
for(int i =0;i<arr.length;i++){
System.out.println("arr"+"["+i+"]"+arr);
}
}
}
4.数组的遍历
数组的算法
完成一个数组的逆序过程
1,3,5,7,9,2,4,6,8==>8,6,4,2,9,7,5,3,1
package day04;
import java.util.Arrays;
public class Demo4 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr){
for(int i=0;i<arr.length/2;i++){
int temp =arr[i];
arr[i] = arr[arr.length -1-i];
arr[arr.length -1-i]=temp;
}
}
}
找出数组中最大值所在下标的位置
package day04;
public class Demo5 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8};
int index = maxIndexOf(arr);
System.out.println(index);
}
public static int maxIndexOf(int[] arr){
//假定下标为0的元素是数组中最大值
int maxIndex =0;
for(int i =0;i<arr.length;i++){
if(arr[maxIndex]<arr[i]){
maxIndex =i;
}
}
return maxIndex;
}
}
找出数组中指定元素所在的下标位置
package day04;
public class Demo6 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,1,3,5,7,9};
int index =indexOf(arr, 5);
if(index>=0){
System.out.println(index);
}else{
System.out.println("no");
}
}
/**
* 找出数组中指定元素出现的下标位置
*/
public static int indexOf(int[] arr,int find){
//假定对应查询数据是不存在的
int index = -1;
//利用循环,从下标为0的元素开始到最大下标,对比是否存在find
for(int i =0;i<arr.length;i++){
//发现指定find元素和下标为i的元素一致
if(find == arr[i]){
//使用index保留对应的下标i
index = i;
//终止循环
break;
}
}
return find;
}
}
获取数组中指定下标的元素
package day04;
public class Demo7 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,1,3,5,7,9};
System.out.println(get(arr,5));
}
/**
* 找出指定下标的元素
*/
public static int get(int [] arr,int index){
//用户指定的index不能超出有效下标范围
if(index<0|| index>arr.length-1){
/**
* 返回任何的数据类型都不合适,可以考虑终止方法,并告诉用户错误是什么
*/
System.out.println("input Paramter is Invaliad");
//当前方法退出
System.exit(0);
}
return arr[index];
}
}
找出元素最小的下标
package day04;
public class Demo8 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8,19};
int min =minIndexOf(arr);
System.out.println(min);
}
public static int minIndexOf(int[] arr){
int min =0;
for(int i =1;i<arr.length;i++){
if(arr[min]>arr[i]){
min = i;
}
}
return min;
}
}
找出元素最后一次出现的位置
package day04;
public class Demo9 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8,19};
int index=lastIndexOf(arr, 19);
System.out.println(index);
}
public static int lastIndexOf(int[] arr,int find){
//假定找不到对应的数据
int index = -1;
for(int i = arr.length-1;i>=0;i++){
//找到对应元素保存index,终止循环
if(find == arr[i]){
index= i;
break;
}
}
return index;
}
}
找出指定元素在指定数组中所有的下标位置
a.不允许在方法内打印
b.考虑到多数据情况
c.需要在方法外获取下标数据信息
d.不允许使用数组作为返回值
package day04;
public class Demo10 {
public static void main(String[] args) {
int [] arr = {1,3,5,7,9,1,3,5,7,9,10};
int [] indexArr = new int[arr.length];
int count = allIndexOf(arr, indexArr, 5);
//count是查询到的指定元素个数,同时可以利用与循环中,找到对应的元素
for(int i =0;i<count;i++){
System.out.println(indexArr[i]);
}
}
public static int allIndexOf(int[] arr,int[] indexArr,int find){
//参数合法性判断
if(arr.length>indexArr.length){
System.out.println("no");
//参数不合法,没有找到数据
return 0;
}
/**
* 定义一个变量。计数器,记录找到元素个数
* 尾插法当中下一次存放元素的位置
*/
int count =0;
//利用循环遍历整个数据arr数组
for(int i =0;i<arr.length;i++){
//找到对应的元素,保存下标i
if(find == arr[i]){
//保存到indexArr数组中
//需要使用尾插法 保存下一次存放数据的位置
indexArr[count]=i;
count +=1;
}
}
return count;
}
}
在指定位置插入指定元素
package day04;
//在指定位置插入指定元素
import java.util.Arrays;
public class Demo11 {
public static void main(String[] args) {
int[] array = {1,3,5,7,9,11,13,15,17,0};
add(array, 5, 20);
System.out.println(Arrays.toString(array));
}
/**
* 在指定的数组中插入指定的元素
* @param arr 指定的int类型数组
* @param index指定的下标位置,必须在合理的区间范围以内
* @param insert 指定插入的元素 int类型
* @return添加成功返回ture
*/
public static boolean add (int[] arr,int index,int insert){
//参数合法性判断
if(index<0||index>arr.length -1){
System.out.println("运行失败");
//方法运行失败
return false;
}
for(int i = arr.length -1;i>index;i--){
arr[i]=arr[i-1];
}
arr[index] = insert;
return true;
}
}
删除数组中指定下标的元素
package day04;
import java.util.Arrays;
public class Demo12 {
public static void main(String[] args) {
int[] array = {1,3,5,7,9,11,13,15,17,0};
remove(array, 3);
System.out.println(Arrays.toString(array));
}
public static boolean remove(int[] arr,int index){
//判断合法性判断
if(index<0||index>arr.length - 1){
System.out.println("方法错误");
return false;
}
for(int i = index;i<arr.length-1;i++){
arr[i]=arr[i+1];
}
arr[arr.length - 1]=0;
return true;
}
}
5.数组的排序
选择排序算法:升序排列 核心(找 换)
package day04;
import java.util.Arrays;
/**
* 选择排序算法
* @author 刘朝阳
*
*/
public class Demo13 {
public static void main(String[] args) {
int[] array = {1,3,5,7,9,11,13,15,17,0};
selectSort(array);
System.out.println(Arrays.toString(array));
}
public static void selectSort(int[] arr) {
//外部循环控制核心算法的循环次数
for(int i =0;i<arr.length- 1;i++){
//聪明和index位置开始寻找极值
int index = i;
for(int j = i+1;j<arr.length;j++){
if(arr[index]<arr[j]){
index = j;
}
}
if(index != i){
int temp = arr[i];
arr[i] = arr[index];
arr[index]=temp;
}
}
}
}
冒泡排序:
package 冒泡排序;
import java.util.Arrays;
/**
* 冒泡排序
* @author mmz
*
*/
public class BubbleSort {
public static void BubbleSort(int[] arr) {
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){//冒泡趟数
for(int j=0;j<arr.length-i-1;j++){
if(arr[j+1]<arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void main(String[] args) {
int arr[] = new int[]{1,6,2,2,5};
BubbleSort.BubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
}
6.数组的应用
Arrays数组工具类的使用
数组的工具类:提供了数组操作的基本方法
sort(int[] arr);
快速排序算法
package day04;
import java.util.Arrays;
public class Demo14 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8,10};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
binarySearch(int[] arr,int find);
二分法查询,要求数组是有序的
package day04;
import java.util.Arrays;
public class Demo14 {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,2,4,6,8,10};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
/**
* 二分法查找
* 1.数据必须有序,无序情况下不保证查询结果情况
* 2.数据未找到,返回负数
* 3.多个相同数据的情况下,不保证找到数据是第几个数据
*/
int index = Arrays.binarySearch(arr, -5);
System.out.println(index);
}
}
toString(任何数据类型);
把数组内容做出一个String类型字符串返回值