数组

数组（array  非常重要）

1：一组相同类型变量的集合。比如定义存放100个int类型变量的数组

2：容器类   引用类型，存放在内存的堆内存中

3：定义define （声明declare）

    Int[]  intArray; int intArray[];(不建议使用)

结构：Datatype [] arrayname;

4：基本数据类型的数组

数组里面的小抽屉默认编号是从0开始的   0称为index 索引   也称为下标

在取数组值时候，不能越界

Index的最大值=数组长度-1

5：数组的遍历

6：遍历的另外一种写法，泛型遍历foreach

7：数组静态初始化

int[] intArr2 = new int[] {1,2,3,4,5,6};

8：引用传递

9：数组作为方法的参数，数组作为方法的返回值

    引用传递与非引用传递

 

1：与for循环相关    通过for循环对数组操作

int length=10;

         int[] array =new  int[10];

        

         for (int i = 0; i < array.length; i++) {

              Random random=new Random();

              int input=random.nextInt(100)+1;

              array[i]=input;

         }

         System.out.println(Arrays.toString(array));

        

//       对数组中元素进行算数操作，仍然使用for循环

         for (int i = 0; i < array.length; i++) {

              array[i]*=10;

         }

         System.out.println(Arrays.toString(array));

        

2：数组中查找某一值

//       判断数组中有没有某一个值

//       变量初始化一般在优化时也赋予初始业务逻辑

         int value=210;

         boolean isFind=false;

         for (int i = 0; i < array.length; i++) {

              if (value==array[i]) {

                   isFind=true;

                   break;

              }

         }

         System.out.println(isFind?"找到了":"找不到");

3：排序   冒泡排序

int[] array = { 9, 3, 5, 1, 7, 6, 5 };

//       冒泡   每一次排序都能获得一个最值

//       核心代码，交换位置

         System.out.println(Arrays.toString(array));

         for (int i = 0; i < array.length; i++) {

              for (int j = 0; j < array.length - 1 - i; j++) {

//                比较交换位置

                   if (array[j] > array[j + 1]) {

                       int temp = array[j];

                       array[j] = array[j + 1];

                       array[j + 1] = temp;

                   }

              }

              System.out.println("第" + (i + 1) + "次遍历:" + Arrays.toString(array));

         }

4：反转   reverse

int[] array1= {1,4,5,6,67,34,3};

         int[] array2= {3,4,5,2,24,2};

//       反转

         int count=array1.length/2;

         int headArray=0;

         int tailArray=array1.length-1;

         for (int i = 0; i < count; i++) {

              int temp=array1[headArray];

              array1[headArray]=array1[tailArray];

              array1[tailArray]=temp;

              headArray++;

              tailArray--;

         }

         System.out.println(Arrays.toString(array1));

    4.1数组个数是奇数

    4.2数组个数是偶数

5：array类的方法

    Sort：

int[] array = { 9, 3, 5, 1, 7, 6, 5 };

//       冒泡   每一次排序都能获得一个最值

//       核心代码，交换位置

         System.out.println(Arrays.toString(array));

         for (int i = 0; i < array.length; i++) {

              for (int j = 0; j < array.length - 1 - i; j++) {

//                比较交换位置

                   if (array[j] > array[j + 1]) {

                       int temp = array[j];

                       array[j] = array[j + 1];

                       array[j + 1] = temp;

                   }

              }

              System.out.println("第" + (i + 1) + "次遍历:" + Arrays.toString(array));

         }

binarySearch：针对已经排序后的数组才可以使用

//       获得结果key所在数组中的索引值，如果为负数，就证明key不在所查找的数组中。

int[] array = {1,2,3,4,5,6,7,8,9};

         Arrays.sort(array);

         System.out.println(Arrays.toString(array))；

//       针对已经排序后的数组才可以使用

//       获得结果key所在数组中的索引值，如果为负数，就证明key不在所查找的数组中。

         int index = Arrays.binarySearch(array, 15);

         System.out.println(index);

 

练习：自定义一个方法实现tostring的效果。

把判断数组中是否存在某一值封装成一个方法。

 

 

import java.util.Arrays;

import java.util.Random;

 

/**

 * @author Administrator

 *

 */

public class ArrayDemo {

 

     /**

      * @param args

      */

     public static void main(String[] args) {

         // TODO Auto-generated method stub

//       定义一个长度为10的数组：

         int[] intArr=new int[10];

//       利用随机数给数组随机赋10个值,赋值范围自己定义

         Random random = new Random();

//       赋值范围[1,10]

         for (int i = 0; i < intArr.length; i++) {

              int input=random.nextInt(10)+1;

              intArr[i]=input;

         }

         System.out.println(Arrays.toString(intArr));

        

//       对intArr进行排序

         /*Arrays.sort(intArr);

          System.out.println(Arrays.toString(intArr));

//       折半查找，查找某一个值在数组中的位置

         int a=Arrays.binarySearch(intArr, 5);

         System.out.println(a);*/

        

//       对数组进行冒泡排序

         /*for (int i = 0; i < intArr.length; i++) {

              for (int j = 0; j < intArr.length-1-i; j++) {

                   if (intArr[j]>intArr[j+1]) {

                       int temp=intArr[j];

                       intArr[j]=intArr[j+1];

                       intArr[j+1]=temp;

                   }

                  

              }

              System.out.println("第"+(i+1)+"次数组遍历:"+Arrays.toString(intArr));

         }*/

        

//       对数组进行反转

         /*int count=intArr.length/2;

         int headArr=0;

         int tailArr=intArr.length-1;

         for (int i = 0; i < count; i++) {

              int temp=intArr[headArr];

              intArr[headArr]=intArr[tailArr];

              intArr[tailArr]=temp;

              headArr++;

              tailArr--;

         }

         System.out.println(Arrays.toString(intArr));*/

        

//       查找数组中是否存在某一值，存在则输出找到，不存在则输出找不到；

        

         boolean isValue=false;

         int b=random.nextInt(10)+1;

         System.out.println("查到数组中是否有"+b);

         int temp=b;

         for (int i = 0; i < intArr.length; i++) {

              if (intArr[i]==b) {

                   isValue=true;

                   break;

              }

         }

         System.out.println(isValue?"找到了":"找不到");

        

     }  

 

}