学习数组：
1、认识数组
在java中出现了[] 代表数组出现了
数组是引用类型
eg：
int[] a={1,2};
2、数组定义
一组数 ：个数很多 专门用来存储数据的 [基本数据类型/引用类型]
一组 存储相同类型元素的 有序的（这里的有序是指下标索引有序） 集合
3、数组的创建方式
声明+初始化
类型[] 变量名;//声明
变量名 = new 类型[长度/存储元素的个数];//初始化
eg:
int[] a;
a=new int[10];
数组创建时做的事情：
a、数组在创建的时候 ，会在堆中开辟一个 存放 N个长度的 连续空间，
b、给数组中每个元素赋初值[依据当前数组类型决定的 例如：int数组 那么初值是0]
{限定： 创建数组的方式是通过new int[4]}
c、将堆中的地址赋给具体的引用变量存放
静态:创建数组对象时 指定了数组的个数以及数组中每个元素的值
int[] nums = new int[]{1,2,3};// 声明了一个存储3个元素的数组 数组中的元素分别是：1，2,3
int[] temps = {2,3,4};//创建一个数组 声明了一个存储3个元素的数组 数组中的元素分别是：2,3,4
动态：创建数组的时候只指定长度 在运行过程当中给数组的每个索引赋值
①：给每个对应的索引赋值
int[] primes = new int[4];
primes[0] = 2;
primes[1] = 3;
primes[2] = 5;
primes[3] = 7;
②：用for循环给每个索引赋值
int[] primes = new int[4];
for(int i = 0;i<primes.length;i++){
primes[i] = (i+1);
}
4、数组的常见属性
索引： 数组中的有序 指的就是索引有序 数组当中的索引的范围是[0——(lenth-1)]
长度：数组通过lenght属性 可以获取当前数组的长度
0<=索引<length
数组是不可变的，数组的长度一旦声明不可更改。
5、数组的CRUD(增删改查)
遍历/迭代：
for迭代数组：
System.out.println("======for迭代数组=======");
for(int i = 0;i<primes.length;i++){
System.out.print(primes[i]+",");
}
System.out.println();
foreach迭代数组：
System.out.println("======foreach迭代数组=======");
for(int temp:primes){
System.out.print(temp+"，");
}
System.out.println();
int类型数组
a、给一个指定长度的数组 进行初始化 初始化的元素范围[13-109]
b、迭代数组中的每个元素
c、修改数组中的某个值。将要修改的值传入 改变的值也传入
d、截取数组 截取数组的指定位置的元素 变为一个新的数组返回
e、给数组排序 从小到大
f、查找数组中指定的元素 如果没有返回-1
g、删除数组中指定的元素 删除一个只完成了基本功能的代码：（垃圾）
public static void main(String[] args) {
//a
/* int[] nums = new int[5];start(nums);*/
//b
/* diedai(nums);*/
//c
/* update(nums, 20, 45);*/
//d
/* diedai(cut1(nums, 4, 7));*/
//e
/* diedai(sort(nums));*/
//f
/* int index=serach(nums, 22);System.out.println(index);*/
//g
/* int[] nums=new int[]{20,21,22,25,18};diedai(delete(nums, 22));*/
}
//初始化数组中每个元素
public static int[] start(int[] a){
for(int i = 0;i<a.length;i++){
a[i] = (int)(Math.random()*97+13);
}
return a;
}
// b、迭代数组中的每个元素
public static void diedai(int[] a){
for (int temp : a) {
System.out.print(temp+",");
}
System.out.println();
}
//c、修改数组中的某个值。将要修改的值传入 改变的值也传入
public static void update(int[] a,int x,int y){
a[serach(a, x)]=y;
diedai(a);
}
// d、截取数组 截取数组的指定位置的元素 变为一个新的数组返回 (复杂)
public static int[] cut(int[] a,int x,int y){
int[] b=new int[y-x];
for (int i = 0; i < a.length; i++) {
if(i==x){
for (int j = 0; j < b.length; j++) {
b[j]=a[i++];
if(i==y){
break;
}
}
diedai(b);
return b;
}
}
return b;
}
// d、截取数组 截取数组的指定位置的元素 变为一个新的数组返回 （简单）
public static int[] cut1(int[] a,int x,int y){
int[] b=new int[y-x];
for (int i = x; i < y; i++) {
b[i-x]=a[i];
}
return b;
}
// e、给数组排序 从小到大 （复杂）
public static int[] sort(int[] a){
int k=0;
for (int i = 0; i < a.length-1; i++) {
for (int j = i+1; j < a.length; j++) {
if(a[i]>a[j]){
k=a[i];
a[i]=a[j];
a[j]=k;
}
}
}
return a;
}
// f、查找数组中指定的元素 如果没有返回-1
public static int serach(int[] a,int x){
for (int i = 0; i < a.length; i++) {
if(a[i]==x){
return i;
}
}
return -1;
}
// g、删除数组中指定的元素 删除一个
public static int[] delete(int[] a,int x){
a[serach(a, x)]=a[a.length-1];
a=Arrays.copyOf(a, a.length-1);
return a;
}老师写的代码（严谨）
/**
* 给一个指定长度的数组 进行初始化 初始化的元素范围[13-109]
* @param arrs 要初始化的数组
* @throws NullPointerException
* @throws ArrayIndexOutOfBoundsException
*/
public static void initArrays(int[] arrs)throws NullPointerException, ArrayIndexOutOfBoundsException{
try{
for(int i = 0;i<arrs.length;i++){
arrs[i] = (int)(Math.random()*97+13);
}
}catch(NullPointerException e){
throw new NullPointerException("传入对象为null");
}catch(ArrayIndexOutOfBoundsException e){
throw new ArrayIndexOutOfBoundsException("传入对象越界");
}
}
/**
* 遍历数组 返回字符串
* @param arrs 要迭代的数组
* @return 数组中的每个元素
*/
public static String toString(int[] arrs){
if(arrs==null){
return "null";
}
int iMax = arrs.length-1;
if(iMax==-1){
return "[]";
}
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i = 0;;i++){
sb.append(arrs[i]);
if(iMax==i){
return sb.append("]").toString();
}
sb.append(",");
}
}
/**
* 截取数组
* @param arrs 要截取的数组
* @param sIndex 起始索引
* @param eIndex 截止索引 不包含
* @return 新数组
*/
public static int[] subArrys(int[] arrs,int sIndex,int eIndex){
//声明返回数组
int[] newArrs = new int[eIndex-sIndex];
//迭代原数组
for(int i =sIndex;i< eIndex;i++){
newArrs[i-sIndex] = arrs[i];
}
return newArrs;
}
/**
* 修改元素
* @param arrs 要修改的数组
* @param oldValue 旧值
* @param newValue 新值
*/
public static void updateByValue(int[] arrs,int oldValue,int newValue){
int index = queryByValue(arrs,oldValue);
try{
arrs[index] = newValue;
}catch(ArrayIndexOutOfBoundsException e){
e.printStackTrace();
}
}
/**
* 根据内容查找元素的索引
* @param arrs 要查找的数组
* @param value 要找的值
* @return 索引
*/
public static int queryByValue(int[] arrs,int value){
for(int i = 0;i<arrs.length;i++){
if(value==arrs[i]){
return i;
}
}
return -1;
}
/**
* 通过二分搜索法 查找元素 必须保证数组有序
* @param arrs 要搜索的数组
* @param value 要查找的值
* @return 索引 如果没找到 返回-1
*/
public static int binerySearch(int[] arrs,int value){
int iMax = arrs.length-1;
int iMin = 0;
int iMid;
while(iMin<=iMax){
iMid = (iMax+iMin)/2;
if(value==arrs[iMid]){
return iMid;
}else if(value>arrs[iMid]){
iMin = iMid+1;
}else{
iMax = iMid-1;
}
}
return -1;
}
/**
* 冒泡排序
* @param arrs
*/
public static void bubbleSort01(int[] arrs){
for(int i=0;i<arrs.length-1;i++){//趟数
System.out.println("第"+(i+1)+"趟");
for(int j = 0;j<arrs.length-1;j++){//次数
//判定是否交换位置
if(arrs[j]>arrs[j+1]){
arrs[j] = arrs[j] ^arrs[j+1];
arrs[j+1] = arrs[j] ^arrs[j+1];
arrs[j] = arrs[j] ^arrs[j+1];
}
System.out.println("第"+(j+1)+"次："+toString(arrs));
}
}
}
/**
* 冒泡排序算法 优化
* @param arrs
*/
public static void bubbleSort02(int[] arrs){
for(int i=0;i<arrs.length-1;i++){//趟数
System.out.println("第"+(i+1)+"趟");
for(int j = 0;j<arrs.length-1-i;j++){//次数
//判定是否交换位置
if(arrs[j]>arrs[j+1]){
arrs[j] = arrs[j] ^arrs[j+1];
arrs[j+1] = arrs[j] ^arrs[j+1];
arrs[j] = arrs[j] ^arrs[j+1];
}
System.out.println("第"+(j+1)+"次："+toString(arrs));
}
}
}
/**
* 冒泡排序算法 优化进阶版
* @param arrs
*/
public static void bubbleSort03(int[] arrs){
for(int i=0;i<arrs.length-1;i++){//趟数
boolean flag = true;
System.out.println("第"+(i+1)+"趟");
for(int j = 0;j<arrs.length-1-i;j++){//次数
//判定是否交换位置
if(arrs[j]>arrs[j+1]){
//异或三次 将两个数进行交换
arrs[j] = arrs[j] ^arrs[j+1];
arrs[j+1] = arrs[j] ^arrs[j+1];
arrs[j] = arrs[j] ^arrs[j+1];
flag = false;
}
System.out.println("第"+(j+1)+"次："+toString(arrs));
}
if(flag){
return;
}
}
}
/**
* 选择排序
* @param arrs
*/
public static void selectedSort(int[] arrs){
for(int i = 0;i<arrs.length-1;i++){
int index = i;
for(int j = i+1;j<arrs.length;j++){
if(arrs[index]>arrs[j]){
index = j;
}
}
if(index!=i){
arrs[index] = arrs[index] ^arrs[i];
arrs[i] = arrs[index] ^arrs[i];
arrs[index] = arrs[index] ^arrs[i];
}
}
}6、数组排序/查找 【排序算法 查找算法】 十大经典排序算法（动图演示）动图演示非常形象生动，很好理解，希望可以帮助到大家。
7、Arrays 对于数组的支持
jdk中通过java.util.Arrays 去操作数组：
String toS = Arrays.toString(primes);
System.out.println(toS);本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
