学习java第七天总结

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了学习java第七天总结相关的知识,希望对你有一定的参考价值。

Day06-day07个人总结

1、一维数组

1、数组的定义:

由数据组成的集合,或数组就是用来表示一组数据的就叫数组。

定义数组:

int[] ints;

double[] doubles

String[] names

每个数组存的数据类型必须一致,访问数组里面的每个数据需要通过数组的索引访问,也就是我们说到的数组下标,数组下标的范围为:0至(n-1),并且数组一旦创建,长度不可改变,数组属于引用类型的数据

 

2、数组的声明:

数据类型 变量名 = 变量值

         数据类型[]  数组变量名;(推荐)

         数据类型        数组变量名[];

3、创建数组

一维数组的创建,采用new来申请内存空间

         Java中使用关键字new 创建数组对象,指定数组的大小,给数组元素的存储分配空间

         格式:数组变量名 = new 数组元素的类型 [数组元素的个数];

    array = new int[5];

4、数组赋值

静态初始化是指,在创建数组对象的同时对数组进行初始化。

静态初始化有两种方式:

1、int[] a = new int[]{1, 2, 3};  //定义并创建数组,并初始化数组的元素为 1、2、3,同时数组的长度也被限定为为3。

2、int[] a = {1, 2, 3};   //效果同上

注意:不能这么写 int[] a = new int[3]{1,2,3};

以上两种方式均不需要定义数组的长度,数组的长度由初始化时元素的个数来决定。

 

动态初始化是指把数组的创建和数组的初始化分开完成。

例如:

int[] a = new int[3]; 

a[0] = 3;  //通过元素索引(下标)来给数组元素赋值

a[1]=4;

a[2]=5;

5、遍历数组

第一种遍历数组的方式:

//第一种遍历方式

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

                                     System.out.print(array[i]+" ");

                   }

                   System.out.println();

                   //第二种遍历方式

                   for(int num : array){

                                     System.out.print(num+" ");

                   }

 

6、排序和查找

1、顺序查找:

数组元素在没有顺序的时候,通过顺序查找的方式来查找,就是挨个找

代码如下:

//顺序查找

         public static int OrderSort(int[] array,int key){

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

                            if(array[i] == key){

                                     return i;

                            }

                   }

                   return -1;

         }

}

 

2、二分法查找:

数组元素在有序的情况下,可以通过二分法的查找方式来查找

代码如下:

public static int twoSort(int[] nums,int num){

                   int min = 0;//用于定义数组最小下标

                   int max = nums.length-1;//用于定义数组最大下标

                   int mid = (min+max)/2;//用于定义数组中间的下标

                   do{

                            //始终取数组中间下标的值跟num比较如果相等则返回这个下标值

                            if(nums[mid] == num){

                                     return mid;

                            }

                            if(nums[mid] > num){

                                     max = mid - 1;

                            }else{

                                     min = mid + 1;

                            }

                            mid = (max+min)/2;

                   }while(min <= max);

                  

                   return -1;

         }

 

3、求数组的最大值和最小值

代码如下:

//求最大数和最小数

         public static void mostSort(int[] nums){

                   int max = nums[0];

                   int min = nums[0];

                   for(int i=1;i<=nums.length-1;i++){

                            if(max<nums[i]){

                                     max = nums[i];

                            }

                   }

                   for(int i=1;i<=nums.length-1;i++){

                            if(min>nums[i]){

                                     min = nums[i];

                            }

                   }

                   System.out.println("最大的数为:"+max);

                   System.out.println("最小的数为:"+min);

         }

4、冒泡排序:

 

5,8,1,7,6 ,3

?????8

????7,8

1,3,5,6,7,8

冒泡排序,就是每次比较,大的元素往后挪,比较完第一遍后,最大的元素排到了数组的最后一位

第二次比较,还是从第一个元素开始和后面的比较,把剩余的最大的元素拍到数组的倒数第二位,第一轮比较的最大元素不参与比较

依次类推。

代码如下:

//冒泡排序从小大大排列

         public static void bubbleSort(int[] nums){

                   int temp = 0;

                   //用于控制需要排序比较的轮数

                   for(int i=0;i<=nums.length-2;i++){

                            //依次两两比较

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

                                     //如果后者小于前者将进行交换

                                     if(nums[j-1]> nums[j]){

                                               temp = nums[j];

                                               nums[j] = nums[j-1];

                                               nums[j-1] = temp;

                                     }

                            }

                   }

 

         }

 

5、选择排序

对数组进行两两比较一次比出大小,进行排序,代码如下:

//选择排序法从大到小排列

         public static void orderSort(int[] nums){

                            int k = 0;

                   for(int i=0;i<=nums.length-2;i++){

                            k = i+1;

                            //通过这个for循环计算出数组中最大的数

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

                                     //并且将最大的数的下标标赋值给k

                                     if(nums[j]>nums[k]){

                                               k = j;

                                     }

                            }

                            //判断k如果不等于i始终将

                            if(k != i){

                                     int temp = nums[i];

                                     nums[i] = nums[k];

                                     nums[k] = temp;

                                    

                            }

                           

                   }

7、可变参数和二维数组

1、什么是可变参数,

可变参数的本质依然是数组,解决在方法重载过程中,需要传递不同参数的情况下可以使用可变参数,只需要定义一个方法即可,代码如下:

public static int getSum(int...ints){

                   int sum = 0;

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

                            sum += ints[i];

                   }

                   return sum;

         }

2、对main方法的认识

在main方法中如下:

public static void main(String[] args)

执行main方法的时候,外界给main方法传递的参数

 

3、数组专家即数组的函数和工具

函数:

Sort();对传入的数组进行升序排序

Arrays.toString();将传入的数组以字符串的形式进行输出

使用方式如下:

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

Arrays.sort(a);//将数组排序

System.out.println(Arrays.toString(a));//字符串形式打印数组

 

以上是关于学习java第七天总结的主要内容,如果未能解决你的问题,请参考以下文章

Java基础学习第七天

JAVA学习第七天

java学习第七天

No_16_0226 Java基础学习第七天

JAVA学习第七天——面向对象

python第七天学习总结