数组的知识点

/*一维数组  数组定义：数组是相同类型数据的有序集合。相同类型的若干个数据，按照一定先后次序排列组合而成。
                    其中，每一个数据成功做一个数组元素/每个数组原属可以通过一个下标来访问他们。
            数组特点：其长度是确定的。数组一旦被从创建，它的大小就是不可以改变的。
                    其元素必须是相同类型，不可以出现混合类型。
                    数组中的元素可以是任何数据类型，包括基本类型和引用类型。*/
//一维数组声明方式：1 type[] arr_name;2 type arr_name[]                    
//数组属引用类型：length（指明它的长度），elements of the array（声明数组，即为告诉计算机类型是什么）
/*数组概述    数组只有一个名称，即标识符；
            元素下标标明了元素在数组中的位置，从0开始；
            数组中的每个元素都可以通过下标来访问；
            数组长度固定不变，避免数组越界。
数组的使用：1生明数组即int{}a；
            2分配空间 ：a = new int[5];
            3、赋值 ：a [0] = 8;
            4、处理数据 a [0] = a[0] * 10。
            查：冒泡排序和选择排序*/
/*冒泡排序：不用中间变量实现两个相同类型的变量交换：1.int a13;int b=5;a=a+b;b=a-b;a=a-b.
^通过异或相同的值等于原来的值。a,b不能指向一个空间。
冒泡排序是対已全部排好序的数组排序最快的
选择排序：是一种简单直观的排序算法。它的工作原理是:第一次从待排序的数据元
素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小
(大)元素,然后放到已排序的序列的末尾。
选择排序和冒泡排序的区别：交换的次数不同。冒泡排序每次比较就要立刻交换，而选择排序是把未
排序最小的数找出来与它应在的位置上的元素交换。相对来说，选择排序交换次数较少，一定程度上
提高了运算效率。”*/
/*数组是数据结构中的一种实现方式，我们在存储数据的时候经常会用到数组，常见的数据结构有：
        线性表
        非线性表
        图
        树
        队列
        栈
        堆

排序算法是面试经常问到的问题：
        面试需求：
                1、写出某种算法
                        冒泡排序
                        选择排序
                        插入排序
                        快速排序
                2、排序算法的时间复杂度（空间复杂度）
                        它是衡量一个数据结构是否合适的衡量标准1
                3、排序算法的稳定性
                        在算法在执行之前和执行之后的数组元素的位置是否发生变化*/

//如何使用数组            
/*int[]a;       //声明数组
int[]avgAge;  //年龄
int[]score;   //分数
a=new int[5];*/  //分的空间内存
//声明数组
    /*int[]score1;      //Java成绩
    intscore2[];      //c#成绩
    String[]name; */    //学生姓名
    //分配内存空间：告诉计算机分配几个连续的空间
    /*score1 =new int[30];   
    avgAge =new int[6];
    name = new String[30];*/
     //数组赋值
    /*score[0] =89;
    score[1] =79;
    score[2] =76;
    方法1：边声明边赋值
    int[]score={89,79,76};
    int[]score=new int[][89,79,76];//不能指定数组长度
    方法2：动态地从键盘录入信息并赋值*/
import java.util.Scanner;
/*public class Math2{
    public static void main(String[] args){
    //数组赋值
    score[0] =89;
    score[1] =79;
    score[2] =76;
    int sum=0;   //初始分数为0
    Scanner input=new Scanner(System.in);   //接收键盘输入
    System.out.println("请输入3位同学的成绩");
    for(int i=0;i<score1.length;i++){     //i<score1.length不超出分配内存空间
        score1[i]=input.nextInt();
        sum=sum+score1[i];
        }
    }
}*/
/*public class Math2{
    public static void main(String[] args){
    int[]score=new int[5];      //成绩数组
    int sum=0;
    Scanner input=new Scanner(System.in);
        System.out.println("请输入五位同学成绩");
    for(int i=0;i<score.length;i++){      //分数的长度lengh是数组的属性
    score[i]=input.nextInt();
    sum=sum+score[i];          //成绩累加
    }
        System.out.println("平均分是"+(double)sum/score.length);//+double是因为平均分可能会有小数*/
    //注意：写明数组的大小，避免数组越界，创建数组并赋值的方式必须在一条语句中完成。
    /*public class Math2{
        public static void main(String args[]){
    int[]s=null;
    s=new int[10];
    for(int i=0;i<10;i++){
        s[i]=2*i+1;
        System.out.println(s[i]);
    }
    }
}*/
/*数组初始化：静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时
就为数组元素分配空间并赋值。
格式：类型[]数组名=[元素1]{,元素2....};
      int [] a    ={1,2,3,4,5};
数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间
其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组的越界：定义并用运算符new为之分配的空间后，才可以引用数组中的每个元素；
每个数组都有一个属性length指明它的长度。
起点：数组名[0]  终点[length-1]*/
     
/*public class Math2{
    public static void mian(String args[]){
    int a[]=new int[2];
    boolean [] b=new boolean[2];
    String[] s =new String[2];
    for(int i=0;i<2;i++){
        System.out.println(a[i]);
    for(int i=0;i<2;i++){
        System.out.println(b[i]);
    for(int i=0;i<2;i++){
        System.out.println(s[i]);
    }
    }