数组知识点
2015-08-30 17:04
435 查看
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]
;
格式二：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]);
}
}
}
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]
;
格式二：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]);
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 通过/dev/mem实现用户层访问GPIO寄存器
- 正则表达式
- HttpSession
- maven的一些错误
- [Leetcode] Binary Tree Paths
- APK反编译二次打包工具和方法
- Codeforces Round #318 B - Bear and Three Musketeers
- python 爬虫3 新浪微博 爬虫 实战
- 自定义adapter的基础上Listview优化方案以及几个小错误（checkbox吃掉点击事件以及对象重复问题）
- windows下，将免安装的tomcat加入系统服务
- PostCSS一种更优雅、更简单的书写CSS方式
- HUD5423 Rikka with Tree（DFS）
- 搜索算法
- CameraRotateAroundTarget
- 反射相关知识点小结
- redis 入门及看法
- 修改 Semantic UI 中对 Google 字体的引用
- 分布式中使用Redis实现Session共享(二)
- Python3Hovercraft创建impressive.js演示文档（一)
- 多线程知识点小结