数组知识点

1:方法的概念?方法的格式?格式的解释说明

2:方法的调用
A:明确返回值类型的方法调用
B:void类型的方法调用

3:方法的练习：
A:求两个数据之和
B:判断两个数据是否相等
C:获取两个数中较大的值
D:打印m行n列的星形矩形
E:打印nn乘法表


4:什么是方法重载?以及方法重载的练习?把讲过的案例练习一次即可
---------------------------------------------------------------
5:数组的概念?有什么特点?
答：数组是用来存储同一种数据类型多个元素的集合，也可以看成一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。
 特点：元素类型必须统一。
6:一维数组的定义格式?
答：数据类型 []变量名=new 数据类型[m]；
int []arr = new int [m];
int []arr = int {8,32,6,5,8,7};
7:数组操作的两个小问题
答：运行产生的两个问题：1.array Index out of Bounds Exception数组脚标越界。2.Null pointer Exception空指针操作标量。
8:数组常见操作:
1.数组遍历(依次输出数组中的每一个元素)
 class ArrTest3 {
  public static void main(String[] args){
int []arr = new int[]{92,9,54,98,26,59};
for (int x=0;x<arr.length ;x++ ){


System.out.print(arr[x]+",");
   }
  }
}


2.数组获取最值(获取数组中的最大值最小值)
/需求：给定一个数组获取最大值。
//分析：遍历数组。取数组中第一个arr[0]设为最大值.调用函数方法就行比较。


class TTTT{


public static void main(String[] args){
      //定义数组
 int []arr = new int[]{29,5,75,6,9,27};
            int c = getMax(arr);
 System.out.print(c);
}

           
//创建一个方法，获取最大值
    //两个明确：1.明确返回值类型（int）2，参数列表：1，个数是：一个  2.类型是整型数组int[]
public static int getMax(int [] arr)
{
//遍历数组
        int  max = arr[0];
  for (int x = 1;x<arr.length ;x++ )
  {
 
  if (max<arr[x])
  {
  max = arr[x];
  } 
  }
   return max;
} 
}
3.数组元素逆序 (就是把元素对调)
//需求：数组元素逆序，就是把数组元素对调。
//分析步骤：1.在主方法定义一个数组，调用函数创建函数将数组中的第一元素,付给变量start，最后一个元素付给end。
         //2，将start与end 交换位置，判断当start>end 时循环结束。
class TTTT{


public static void main(String[] args){
     //定义数组
int []arr = new int[]{62,59,96,52,89};
//调用方法
        getChange(arr);
for (int x=0;x<arr.length ;x++ ) {

if (x==arr.length-1){ 
               System.out.print(arr[x]+"}");
}else if(x==0){
System.out.print("{"+arr[x]+",");
}else{
System.out.print(arr[x]+",");
}
      }
  }
     //创建函数方法
// 两个明确：1.明确返回值类型是void，2.明确参数列表（1）参数个数是一个（）参数类型整型数组int[]arr
public static void getChange(int [] arr){
//定义变量

        for (int start=0,end=arr.length-1;start<end ;start++,end-- ) {     
             int temp= arr[start];
         arr[start]=arr[end];
      arr[end]=temp;
       }  
 
   }
}




4.数组查表法(根据键盘录入索引,查找对应星期)


 //需求：数组查表法(根据键盘录入索引,查找对应星期)
//分析：一：导入键盘录入1.导入包，2，创建对象。3.获取数据
//      二：在主方法中创建数组调用函数
//     三：创建函数。遍历数组输出对应索引的数组元素
//导入包
import java.util.Scanner;
class ArrayDemo  
{     
public static void main(String[] args) 
{    
while (true)//可以在dos命令中持续输入数字无限循环
{

          //创建对象
 Scanner sc = new Scanner (System.in);
       System.out.print("我们又见面了啊请输入吧。。。。。");
    //获取数据
int number = sc.nextInt();
//创建数组
         String []arr = new String []{"不存在","星期一","星期二","星期三","星期四","星期五","星期六","星期天"}; 


getWeek(arr,number);}
     }
//创建方法 两个明确：1.返回值类型string 2.参数列表2个   类型int []arr   int 
public static void getWeek(String []arr , int number){
  if (number<1|number>7){  
                 System.out.print("您输入有误...");
  }else{
   System.out.print(arr[number]);
}
  }  
  }    
// return arr[number];


5.数组元素查找(查找指定元素第一次在数组中出现的索引)
  //需求：查找指定元素第一次在数组中出现的索引
//分析；定义一个数组，将定数组的某一个想要求的值arr[x]=number.
//      则number对应的索引就是你想要球的值。
class ArrTest3 {
  public static void main(String[] args){
    //定义一个数组
int []arr = new int[]{62,58,74,32,65,32,82};
//调用函数
      int index = getIndex(arr,32);
        System.out.println(index);


  }
    //创建函数两个明确：1.明确函数类型为int 2.参数列表：（1）个数2个（2）参数类型int[] arr  int number 
public static int getIndex(int [] arr, int number){
//初始化index
int index=-2;
 //遍历数组
 for (int x=0;x<arr.length ;x++ ){ 
 if (number==arr[x]){ 
 index=x;
break;//如果没有会怎么样？
 }
 }
    //System.out.println()
     return index;//什么时候返回这个值。
}
}
9:二维数组定义格式?
答：格式一：int [][]arr = new int[m][n];
     格式二：int [][]arr= new int[3][];
      格式三：int [][]arr= {{4，3，2}，{2，3，5，2，4}，{2，5，4，3，2}，{2，3，5，4，3，2}，{3，2，5，2}}
  看懂针对每种格式的内存图解?

10:案例-- 理解即可  
A:二维数组遍历
B:公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

11:思考题(思考题文件夹)
A:参数传递问题(重要)

B:杨辉三角(扩展)

重载小知识点

/*

如果方法的功能一样的,起名字就很麻烦了.非常大胆,既然方法的功能是一样的,那么我就给起一个相同的名字.虽然名字相同,但是对于调方法来说,靠参数来区分的.

方法重载的条件:
1.方法名字相同
2.参数列表不同 

注意: 跟返回值类型无关 

比较两个数据是否相等。

两个明确:
返回值类型: boolean 


参数列表 :
个数:2
类型 : byte

参数类型分别为两个byte类型，
 两个short类型，
 两个int类型，
 两个long类型，
并在main方法中进行测试

*/

class ChongZaiDemo{


public static void main(String[] args){

//System.out.println( sum(5,6));
//System.out.println( sum(5,6,7));
System.out.println( sum(5,6,7,8));




}


public static int sum(int a,int b){
System.out.println("两个数的和");

return a + b;
}

// public static double sum(int a,int b){  // 错误: 已在类 ChongZaiDemo中定义了方法 sum(int,int)
//
// return  0.0;
// }

public static int sum(int a,int b,int c){
System.out.println("三个数的和");

return a + b + c;
}
public static int sum(int a,int b,int c,int d){
System.out.println("四个数的和");

return a + b + c + d ;
}

}

数组

/*
静态初始化 :


格式:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
int []arr = int arr[3];


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



简化格式 :
int[] arr = {1,2,3,4,5};


*/


class ArrayDemo3{


public static void main(String[] args){


//静态初始化数组  




int[] arr = {11,22,33,44,55,4564,56776,834,5678,89,95675679,979};




printArray(arr);
int m = getMax(arr);


System.out.println("数组最大的值是:"+ m);



// for ( int x=0; x<arr.length;x++ ){
// System.out.println(arr[x]);
//
// }
}




/*

两个明确:
返回值类型: void
参数列表:
个数:1
类型:int[] 


[11,22,33,44,55]

*/


public static void printArray(int[] arr){
System.out.print("[");
for ( int x=0; x<arr.length;x++ ){
//判断,如果不是最后一个
if (x != arr.length-1){
System.out.print(arr[x]+",");
}else{
System.out.print(arr[x]+"]");
}
}
}


/*
获取数组最大值的方法 


两个明确: 
返回值类型 : int 
参数列表:
个数：1
类型：int[]

*/


public static int getMax(int[] arr){
//定义变量
int max = arr[0];


for (int x=1; x<arr.length ; x++ ){
//判断 
if (max < arr[x]){  //max 比下一个元素小
max = arr[x];
}
}
return max;
}
}

数组操作

/*
A:案例演示
    数组元素反转(就是把元素对调)

[1,2,3,4,5]

[5,4,3,2,1]

分析:
1.定义数组 

2.对调操作 
1.定义两个角标为
初始角标位,int start =0

末尾角标位, int end = arr.length-1

2.循环对调  
定义第三方变量 
int temp  = arr[end];
arr[end] = arr[start];
arr[start] = temp;
//对调后,操作角标  
start ++
end -- ;
3.对调结束 

*/
class OperatorArrayDemo5{

public static void main(String[] args){

//定义数组 
int[] arr = {11,22,33,44,55,66};
printArray(arr);
reverse(arr);
System.out.println();
printArray(arr);
}

/*
对调的方法 


两个明确:
返回值类型: void
参数列表:
个数:1
类型: int[] 
*/
public static void reverse(int[] arr){
//初始角标位,
int start =0;


//末尾角标位, 
int end = arr.length-1;


//不关心次数的循环,用while 


while ( start <end ){
//对调操作 
int temp  = arr[end];
arr[end] = arr[start];
arr[start] = temp;


//对调后,操作角标  
start++;
end--;


}
}
public static void printArray(int[] arr){
System.out.print("[");
for ( int x=0; x<arr.length;x++ ){
//判断,如果不是最后一个
if (x != arr.length-1){
System.out.print(arr[x]+",");
}else{
System.out.print(arr[x]+"]");
}
}
}
}

二维数组

/*
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

季度作为一维数组 

int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

*/

class Operator2Array2{


public static void main(String[] args){

//全年的销售额
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

int total = totalSale(arr);

int average = total/12;

System.out.println("全年的销售额为:"+ total+ "万元,平均每个月销售" + average +"万元");
}

/*
1.int sum,做为求和变量 
2.遍历,获取到每一个元素  
3.返回sum 


*/

public static int totalSale(int[][] arr){

//定义和的变量 
int sum = 0;

for ( int x=0; x<arr.length;x++ ){
//System.out.println(arr[x]);
//二维数组的元素,就是一维数组
for ( int y=0; y<arr[x].length; y++){
//一维数组中的元素,就是值  
//System.out.println(arr[x][y]);

sum += arr[x][y];
}
}

return sum;
}

public static void print2Array(int[][] arr){

//遍历

for ( int x=0; x<arr.length;x++ ){
//System.out.println(arr[x]);
//二维数组的元素,就是一维数组
for ( int y=0; y<arr[x].length; y++){
//一维数组中的元素,就是值  
System.out.println(arr[x][y]);
}
}

}