文章目录
 
数组定义与使用
1.数组的基本用法
*1.1什么是数组**
**1.2创建数组**
1.3遍历数组
   
2.数组作为方法的参数
*2.1基本用法*
**2.2理解引用类型**
2.3jVM内存区域
**2.4数组转字符串**
**2.5拷贝数组**
*2.6二分查找**
**2.7数组排序**
  
 

 
数组定义与使用
 
1.数组的基本用法
 
1.1什么是数组*
 
相同数据类型的集合，内存是连续的
 
1.2创建数组
 
数据类型[] 数组名称=new 数据类型[数组长度]
 
     int[]   array=new int[5];//定义好了数组没有初始化，默认为0，new产生一个对象
     int[]   array1=new  int[]{1,2,3};//动态初始化
     int[]   array2={1,2,3};//静态初始化
 
array 为一个引用类型变量，存放的是首元素的地址
 
Int[]  array={ }//长度为0
System.out.print(array.length);//空指针异常
String str=null;//null是所有引用变量的初始化
System.out.println(str.length);//空指针异常
 
array.length能够获得数组长度[0,length-1]，length为一个属性
 
String str="asdfef";//6
System.out.println(str.length());//length（ )为方法
int[]  arr=new  int[4];
System.out.println(arr[100]);//java.lang.ArrayIndexOutOfBoundsException数组越界    
 
1.3遍历数组
 
1.int[] array={1,2,3};
for(int i=0;i<arr.length;i++){
   System.out.println(arr[i]);
}
  2.int[]  array={1,23,4,5};
   for(int x:arr)
    System.out.println(x);
     
    
 
for-each(表达式1：表达式2）
 for循环和for-each循环的区别：
 1.for-each当中的值不能用下去标访问
 2.for循环次数多，for-each可以避免循环条件和更新语句的写错
 
2.数组作为方法的参数
 
2.1基本用法
 
打印数组内容
 
public static   void    printArray(int[]   array){
        for(int x:array)
            System.out.println(array);
     }
 
2.2理解引用类型
 
public class Test{
 public static   void  main(String[]   args){
 int num=0;
 func(num);
 System.out.println(num);
 }
public static void func(int  x ){
        x=10;
        System.out.println("x ="+ x);
    }
    }//num=0,x=10
 
过程如图：
 
 修改x的值，不影响实参的值
 参数传数组类型:
 
public class Test{
 public static   void  main(String[]   args){
         int[] array={1,2,3};
          func(num);
         System.out.println(num);
         }
 public  static   void  func1(int[]  a){
        a[0]=10;
        System.out.println(a[0]);
    }
    }//a[0]=10,array[0]=10
 
int[ ] a=array
 
 修改a[0]的值
 
 
2.3jVM内存区域
 

 》程序计数器：只是一个很小的空间，保存下一条指令的地址
 》虚拟机栈:存储局部变量表，例如int[] arr
 》本地方法栈：保存的是native方法局部变量，底层有c/c++实现
 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数
 JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数
 》堆：JVM管理的最大内存区域，使用new创建的对象在堆上保存
 》方法区：用于存储已被虚拟机加载的类的信息，常量，静态变量，即使编译器编译后的代码等数据，字节码文件也保存在这个区域
 》运运行时常量池：存放字面量与符号引用，例如String str=" hello"中的**“hello”**就存放在里面
 
2.4数组转字符串
 
1. Arrays.toString( )//Arrays当中操作数组的工具类
    2.public static String toString(int[] array) {
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
            if (i != array.length - 1)
                ret+= ",";
        }
        ret += "]";
     }
 
2.5拷贝数组
 
1.public  static   int[]   copyArray(int[]  array,int[] array2){
         array2=new  int[array.length];
        for(int i=0;i<array.length;i++){
            array2[i]=array[i];
        }
        return  array2;
    }
 
2.Arrays.copyOf(arr,arr.length)arr原数组，arr.length复制数组的长度，只能从起始位置开始复制 
 
int[] newArr=Arrays.copyOf(array,array.length);
    System.out.println(Arrays.toString(newArr));
 
  3.arraycopy()方法
 
函数原型：arraycopy（Object src, int srcPos, Object dest, int destPos, int length）
 src: 原数组 srcPos:原数组起始的位置
 dest:目的数组 destPos:目的数组的起始位置
 length：所需复制数组的长度
 需要注意的是要重新声明一个同类型且长度足够的数组，否则会出现异常
 
   int[]   newArr1=new   int[array.length];
           System.arraycopy( array,0,newArr1,0,3);
           System.out.println(Arrays.toString(newArr));
 
4. int[]     newArr2=new int[array.length];
              newArr2=array.clone( );
              System.out.println(Arrays.toString(newArr2))
 
5.System.arraycopy( )和Arrays.copyOf( )的区别和联系：
 arraycopy被native所修饰的方法，运行速度快
 copyOf方法内部调用了arraycopy，方法的返回为数组
 
2.6二分查找*
 
前提：有序
 N*（1/2）^Y=1；
 时间复杂度： Y = Log2N.
 
 1.public  static int   binarySearch(int[]  array,int toFind){
        int left=0;
        int right=array.length;
        while(left<right) {
            int mid = (left + right) / 2；
            //在左半区
            if (toFind < array[mid]) {
                right = mid - 1;
            } else if (toFind >array[ mid]) {//在右半区
                left = mid + 1;
            } else {
                return  mid;
            }
        }
        return -1;//没有找到
    }
 
2.二分查找递归
    public  static   int  binarySearch(int[]  array,int key,int left,int right) {
        if (left > right) {
            return -1;//没有找到
        }
       int  mid = (left + right) / 2;
        if (array[mid] == key) {//找到key
            return mid;
        } else if (array[mid] > key) {//在前半部分
           return  binarySearch(array, key, left,mid - 1);
        } else {//在后部分
           return  binarySearch(array, key, mid + 1,right);
        }
    }
 
3.Arrays.binarySearch( )前提为有序
 》binarySearch(T[ ] a, int fromIndex, int toIndex, T key)
 使用二进制搜索算法搜索指定对象的指定数组的范围。
 a：要搜索的数组
 fromIndex：指定范围的开始处索引（包含）
 toIndex：指定范围的结束处索引（不包含）
 key：要搜索的值
 如果要搜索的元素key在指定的范围内，则返回搜索值的索引；否则返回-1或“-”（插入点）。
 程序：
 
  int arr [] =new int[]{1,3,4,5,8,9};
     System.out.println(arr.length+1);
      Arrays.sort(arr);
      int index5 = Arrays.binarySearch(arr,1, 4, 6);
      int index6 = Arrays.binarySearch(arr,1, 4, 4)；
      int index7 = Arrays.binarySearch(arr,1, 4 ,2);
     int index8 = Arrays.binarySearch(arr,1, 3, 10);
     int index9 = Arrays.binarySearch(arr,1, 3, 0);
     System.out.println("index5 = "+ index5 +", index6 = " + index6 +
  ", index7 = " + index7 +", index8 = "+ index8 +“，index”+index9）；
 
结果：index5 = -5, index6 = 2,index7 = -2, index8 = -4, index9 = -2
 》binarySearch(Object[], Object key)
 a: 要搜索的数组
 key：要搜索的值
 如果key在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素的索引。
 程序：
 
  int arr [] =newint[]{1,3,4,5,8,9};

    Arrays.sort(arr);

   int index1 = Arrays.binarySearch(arr,6);

   int index2 = Arrays.binarySearch(arr,4);

   int index3 = Arrays.binarySearch(arr,0);

   int index4 = Arrays.binarySearch(arr,10);

    System.out.println("index1 = "+ index1 +", index2 = " + index2 +

                    ", index3 = " + index3 +", index4 = "+ index4);
 
结果：index1= -5, index2 = 2, index3 = -1, index4 = -7
 
2.7数组排序
 
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次
 冒泡排序总的平均时间复杂度为：O(n2) 。
 
1.冒泡排序
public static void  bubbleSort(int[] array){
        //趟数
        for(int i=0;i<array.length-1;i++){
            //两两比较
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[i]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
 
2.Arrays.sort(arr);
 
2.7数组逆置
 
 public static void reverse(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
           int temp=arr[left];
           arr[left]=arr[rigth];
           arr[rigth]=temp;
           left++;
           rigth--;
        }
    }
 
数组数字排列，奇数在前，偶数在后
 
public static void  m(int[] array) {
        int left=0;
        int right=array.length-1;
        while(left<right){
        //该循环结束，指向一个偶数
            while(left<right&&array[left]%2!=0){
                left++;
            }
            //该循环结束，指向一个奇数
            while(left<right&&array[right]%2==0){
                right--;
            }
            if(left<right){
                int temp=array[left];
                array[left]=array[right];
                array[right]=temp;
            }
        }
    }

(C++)动态一维数组及二维数组定义方法
 
动态一维数组
 
动态二维数组
 
 
 
动态数组：是指在声明时没有确定数组大小的数组，即忽略圆括号中的下标；当要用它时，可随时用ReDim语句重新指出数组的大小。使用动态数组的优点是可以根据用户需要，有效利用存储空间。
 特点：数组到底应该有多大才合适，有时可能不得而知。所以希望能够在运行时具有改变数组大小的能力。
 动态数组就可以在任何时候改变大小。在Visual Basic中，动态数组最灵活、最方便，有助于有效管理内存。例如，可短时间使用一个大数组，然后，在不使用这个数组时，将内存空间释放给系统。
 如果不用动态数组，就要声明一个数组，它的大小尽可能达到最大，然后再抹去那些不必要的元素。但是，如果过度使用这种方法，会导致内存的操作环境变慢。
 
 
动态一维数组的定义方法
 
#include<iostream>
using namespace std;
int main()
{
	int n;
	cin >> n;//定义数组的长度
	int* a = new int[n];//动态一维数组的定义方法
	for (int i = 0; i < n; i++)//循环给数组赋值
	{
		cin >> a[i];
	}
	for (int i = 0; i < n; i++)//循环输出数组
	{
		cout << a[i] << " ";
	}
	return 0;
}
 
动态二维数组的定义方法
 
#include<iostream>
using namespace std;
int main()
{
	int n, m;//定义行和列
	cin >> n >> m;
	//动态定义二维数组并进行赋值
	int** a = new int* [n];
	for (int i = 0; i < n; i++)
	{
		a[i] = new int[m];
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cin >> a[i][j];
		}
	}
	//输出二维数组
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

一维数组的定义与初始化
 
一维数组指的是只有一个下标的数组，它用来表示一组具有相同类型的数据。在C语言中，一维数组的定义方式如下所示
 
 
 
类型说明符 数组名[常量表达式];
 
 
在上述语法格式中，类型说明符表示数组中所有元素的类型，常量表达式指的是数组的长度，也就是数组中存放元素的个数。
 
例
 
 
 
int array[5l;
 
 
上述代码定义了一个数组，其中，int是数组的类型，aray是数组的名称，方括号中的5是数组的长度。完成数组的定义后，只是对数组中的元素开辟了一块内存空间。这时，如果想使用数组操作数据，还需要对数组进行初始化。数组初始化的常见的方式有3种，具体如下
 
（1）直接对数组中的所有元素赋值，示例代码如下：
 
 
 
int i[5]={1,2,3,4,5};
 
 
上述代码定义了一个长度为5的数组i，并且数组中元素的值依次为1、2、3、4、5。
 
（2）只对数组中的一部分元素赋值，示例代码如下
 
 
 
int i[5]={1,2,3};
 
 
在上述代码中，定义了一个int类型的数组，但在初始化时，只对数组中的前3个元素进行了赋值，其他元素的值会被默认设置为
 
（3）对数组全部元素赋值，但不指定长度，示例代码如下：
 
 
 
int i[]={1,2,3,4};
 
 
在上述代码中，数组i中的元素有4个，系统会根据给定初始化元素的个数定义数组的长度,因此，数组i的长度为4。
 
注意
 
（1）数组的下标是用方括号括起来的，而不是圆括号；
 
（2）数组名的命名同变量名的命名规则相同；
 
（3）数组定义中，常量表达式的值可以是符号常量，如下面的定义就是合法的。
 
 
 
int a[N]; //假设预编译命令#define N 4，下标是符号常量
 
 
一维数组的引用
 
在程序中，经常需要访问数组中的一些元素，这时可以通过数组名和下标来引用数组中
 
的元素。一维数组元素的引用方式如下所示：
 
 
 
数组名 [下标];
 
 
在上述方式中，下标指的是数组元素的位置,数组元素的下标是从0开始的。例如，引用数组X的第3个元素的方式为X[2]为了帮助大家更好地理解数组元素的引用榜下业通计一个室例来演示，如下所示：
 
 
 
#include<stdio.h>
 
 
void main(int argc, char *argv[]){
 
 
    int x[5] = {2,3,1,4,6};
 
 
    int i;
 
 
    for (i = 0; i < 5; i++) {
 
 
        printf("%d\n", 2 * x[i]);
 
 
    }
 
 
}
 
 
运行结果若下图所示：
 
 
在上面案例中，首先定义了一个数组x，然后通过下标的形式获取到数组中的元素，最后将元素乘以2后输出。
 
注意
 
数组的下标都有一个范围,即“0~[数组长度-1]”，假设数组的长度为6，其下标范围为0~5。当访问数组中的元素时，下标不能超出这个范围，否则程序会报错。
 
 
 
一维数组的常见操作
 
数组在编写程序时应用非常广泛，如经常需要对数组进行遍历、获取最值、排序等操作灵活地使用数组对实际开发很重要。接下来针对一维数组的常见操作进行详细的讲解，具体如下。
 
1、一维数组的遍历
 
在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。接下来使用for循环依次遍历数组中的元素，如下所示：
 
 
 
#include<stdio.h>
 
 
void main(int argc, char *argv[]){
 
 
    int x[5] = {2,3,1,4,6};
 
 
    int i = 0;
 
 
    for (i = 0; i < 5; i++) {
 
 
        printf("x[%d]:%d\n", i, x[i]);
 
 
    }
 
 
}
 
 
运行结果如下：
 
 
在上面案例中，首先定义了一个长度为5的数组X，然后定义了一个变量，由于数组的下标范围为0-4，因此可以将i的值作为下标，依次去访问数组中的元素，并将元素的值输出。
 
2、一维数组的最值
 
在操作数组时，经常需要获取数组中元素的最值。接下来通过案例演示如何获得数组中最大的数值。
 
 
 
#include<stdio.h>
 
 
int main(int argc, char *argv[]){
 
 
    int x[5] = {2,3,1,4,6};
 
 
    int nMax = x[0];
 
 
    int i = 0;
 
 
    for (i = 0; i < 5; i++) {
 
 
        if (x[i] > nMax) {
 
 
            nMax = x[i];
 
 
        }
 
 
    }
 
 
 
 
 
    printf("max:%d\n", nMax);
 
 
    return 0;
 
 
}
 
 
运行结果如下
 
 
在上面案例找那个实现了获取数组X最大值的功能。在第5行代码中假定数组中的第1个元素为最大值，并将其赋值给nMax，在第7~13行代码对数组中的其他元素进行遍历，如果发现比mMax值大的元素，就将最大值nMx设置为这个元素的值，这样，当数组遍历完成后,nMax中存储的就是数组中的最大值。
 
3、一维数组的排序
 
在操作数组时，经常需要对数组中的元素进行排序。接下来为大家介绍一种比较常见的排序算法一冒泡排序。在冒泡排序的过程中，不断地比较数组中相邻的两个元素，较小者向上浮、较大者往下沉，整个过程和水中气泡上升的原理相似，接下来，分步骤讲解冒泡排序的整个过程，具体如下。
 
第1步，从第1个元素开始，将相邻的两个元素依次进行比较，直到最后两个元素完成比较。如果前1个元素比后1个元素大，则交换它们的位置。整个过程完成后，数组中最后1个元素自然就是最大值，这样也就完成了第1轮的比较。
 
第2步，除了最后1个元素，将剩余的元素继续进行两两比较，过程与第1步相似，这样就可以将数组中第二大的数放在倒数第2个位置。
 
第3步，依次类推，持续对越来越少的元素重复上面的步骤，直到没有任何一对元素需要比较为止。
 
了解了冒泡排序的原理之后，接下来通过一个案例来实现冒泡排序。
 
 
在上面的案例中，通过嵌套for循环实现了冒泡排序。其中，外层循环用来控制进行多少轮比较，每一轮比较都可以确定1个元素的位置，由于最后1个元素不需要进行比较，因此，外层循环的次数为数组的长度-1，内层循环的循环变量用于控制每轮比较的次数，在每次比较时,如果前者小于后者，就交换两个元素的位置。下面通过一张动图来演示冒泡排血的运算过程。
 
 
学C++推荐http://yun.itheima.com/map/25.html?2020zylyk