黑马程序员——Java基础---方法与数组操作
2015-08-11 23:00
656 查看
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、方法
(一)方法的定义及格式
定义：完成特定功能的代码块
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}
(二)方法格式的解释说明
修饰符：比较多，目前public static
返回值类型：用于限定返回值的数据类型
方法名：一个名称，为了方便我们调用方法
参数类型：限定调用方法时传入参数的数据类型
参数名：是一个变量，接收调用方法时传入的参数
方法体：完成功能的代码
return 结束方法以及返回方法指定类型的值
返回值：程序被return带回的结果，返回给调用者
(三)如何写一个方法呢?
两个明确
明确返回值类型
明确参数列表：明确有几个参数，以及参数的类型
(四)方法的注意事项
1. 方法不调用不执行
2. 方法与方法是平级关系，不能嵌套定义
3. 方法定义的时候参数之间用逗号隔开
4. 方法调用的时候不用在传递数据类型
5. 如果方法有明确的返回值，一定要有return带回一个值
(五)方法调用
1. 有明确返回值的方法调用(必须使用return返回，结束方法)
单独调用，没有意义，比如：add(3,9);
输出调用，有意义，但是不够好，因为不一定非要把结果输出，比如：
System.out.println(add(3,9));
赋值调用，推荐方式，比如：int c = add(3,9);
有明确返回值的方法练习：
①键盘录入三个数据，返回三个数中的最大值(If 嵌套实现,临时变量实现)
import java.util.Scanner;
class FunctionGetMax1{
public static void main(String[] args){
//创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数");
//定义变量，接收数据
int num1 = sc.nextInt();
System.out.println("请输入第二个数");
int num2 = sc.nextInt();
System.out.println("请输入第三个数");
int num3 = sc.nextInt();
int max = getMax(num1,num2,num3);
System.out.println("三个数中的最大值为："+max);
}
public static int getMax(int num1,int num2, int num3){
//定义临时变量，保存结果
int max = 0;
if (num1 > num2){
if (num1 > num3){
max = num1;
}
}
else if (num2 > num3){
max = num2;
}
else max = num3;
return max;
}
}
运行结果：
2. 没有明确返回值的方法调用(return可以省略)
其实就是void类型方法的调用
只能单独调用
没有明确返回值(返回值为void类型)的方法练习:
①键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
import java.util.Scanner;
class MulList{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据n(1<=n<=9)");
int x=sc.nextInt();
nineList(x);
}
public static void nineList(int i){
int count;
//输出行
for (int m=1;m<=i ;m++ ){
//输出列
for (int n=1;n<=m ;n++ ){
count=m*n;
System.out.print(n+"*"+m+"="+count+"\t");
}
System.out.println();
}
}
}
运行结果：
(六)方法重载
1. 方法重载概述：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2. 方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
方法重载练习：
①比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
class Load{
public static void main(String[] args){
byte b1 = 1;
byte b2 = 2;
short s1 = 1;
short s2 = 1;
int i1 = 3;
int i2 = 2;
long l1 = 4L;
long l2 = 4L;
load(b1,b2);
load(s1,s2);
load(i1,i2);
load(l1,l2);
}
public static void load(byte b1,byte b2 ){
String s = (b1==b2)?"相等" : "不相等";
System.out.println("这两个byte类型数" + s);
}
public static void load(short s1,short s2 ){
String s = (s1==s2)?"相等" : "不相等";
System.out.println("这两个short类型数" + s);
}
public static void load(int i1,int i2 ){
String s = (i1==i2)?"相等" : "不相等";
System.out.println("这两个int类型数" + s);
}
public static void load(long l1,long l2 ){
String s = (l1==l2)?"相等" : "不相等";
System.out.println("这两个long类型数" + s);
}
}
运行结果：
二、数组
(一)数组概念：
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
(二)数组特点:
1.能够装多个元素.
2.元素类型必须是同一类型
(三)数组定义格式：
格式1：数据类型[] 数组名;
举例：int[] arr ;
格式2：数据类型 数组名[];
举例：int arr[];
(四)数组初始化概述：
Java中的数组必须先初始化，然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
(五)数组的初始化方式
1. 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
(1)格式：数据类型[] 数组名 = new 数据类型[数组长度];
(2)数组长度其实就是数组中元素的个数。
举例：int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
2. 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
(1)格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：int[] arr = new int[]{1,2,3};
这种写法的简化的写法：int[] arr = {1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
(六)Java中的内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈：存储局部变量
堆：存储new出来的东西
方法区(面向对象)
本地方法区 (和系统相关)
寄存器 (给CPU使用)
(七)数组操作常见的两个小问题
1. 数组索引越界
ArrayIndexOutOfBoundsException：访问到了数组中的不存在的索引时发生。
2. 空指针异常
NullPointerException：数组引用没有指向实体，却在操作实体中的元素时。
(八)数组基本操作
1. 数组遍历(依次输出数组中的每一个元素)
class ArrayPrint{
public static void main(String[] args){
//定义一个数组
int[] arr = {11,22,33,44,55};
printArray(arr);
}
public static void printArray(int[] arr){
for (int x=0; x<arr.length; x++){
System.out.println(arr[x]);
}
}
}
运行结果：
2. 数组获取最值(获取数组中的最大值最小值)
class ArrayGet{
public static void main(String[] args){
int[] arr={99,1,3,5,8,33,23,89};
int min=getMin(arr);
System.out.println("数组中的最小值为："+min);
int max=getMax(arr);
System.out.println("数组中的最大值为："+max);
}
public static int getMin(int[] arr){
//定义变量，存储结果
int min=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (min>arr[i]){
min=arr[i];
}
}
return min;
}
public static int getMax(int[] arr){
int max=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (max<arr[i]){
max=arr[i];
}
}
return max;
}
}
运行结果：
3. 数组元素逆序 (就是把元素对调)
class ArrayDuiDiao{
public static void main(String[] args){
int[] arr={11,22,33,44,55};
//反转前
display(arr);
//互换
huHuan(arr);
//反转后
display(arr);
}
public static void huHuan(int[] arr){
int start=0;
int end=arr.length-1;
while (start<end){
int t=arr[start];
arr[start]=arr[end];
arr[end]=t;
start++;
end--;
}
}
public static void display(int[] arr){
for (int i=0;i<arr.length ;i++ ){
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
运行结果：
4. 数组查表法(根据键盘录入索引,查找对应星期)
import java.util.Scanner;
class ArraySelect{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的星期。。。");
int week=sc.nextInt();
String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
String a=getWeek(week,arr);
System.out.println("你查询的是："+ a);
}
public static String getWeek(int x,String[] arr){
if(x>0&&x<8){
return arr[x-1];
}
return null;
}
}
运行结果：
5. 数组元素查找(查找指定元素第一次在数组中出现的索引)
import java.util.Scanner;
class ArrayIedex{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的元素：");
int n=sc.nextInt();
int[] arr={3,44,55,32,12,66,89,76,43,3,53,99,100,10,20,30};
int index=getIndex(n,arr);
System.out.println("指定元素的索引为："+index);
}
public static int getIndex(int num,int[] arr){
int index=-1;
for (int i=0;i<arr.length ;i++ ){
if (num==arr[i]){
index=i;
break;
}
}
return index;
}
}
运行结果：
(九)数组高级操作
1. 数组排序
(1)选择排序
package high_operate;
public class SelectSort {
public static void main(String[] args) {
int[] arr={2,5,6,19,9,0,1,3,8,7};
System.out.println("选择排序前：");
printArray(arr);
System.out.println("选择排序后：");
select(arr);
printArray(arr);
}
//选择排序
public static void select(int[] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = i+1; j < arr.length; j++) {
if (arr[i]>arr[j]) {
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (i!=arr.length-1) {
System.out.print(arr[i]+",");
}
else System.out.println(arr[i]+"]");
}
}
}
运行结果：
(2)冒泡排序
package high_operate;
public class BubbleSort {
public static void main(String[] args) {
int[] arr={7,5,3,2,65,77,43,12};
System.out.println("冒泡排序前：");
printArray(arr);
System.out.println("冒泡排序后：");
bubble(arr);
printArray(arr);
}
//冒泡排序
public static void bubble(int[] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if (arr[j]>arr[j+1]) {
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (i!=arr.length-1) {
System.out.print(arr[i]+",");
}
else System.out.println(arr[i]+"]");
}
}
}
运行结果：
2.数组查找
(1)基本查找
package high_operate;
import java.util.Scanner;
public class BasicSearch {
public static void main(String[] args) {
int[] arr={23,13,44,55,3,2,90,23,7,5};
//创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数字：");
int num=sc.nextInt();
int index=search(arr,num);
System.out.println("你所查找数字的索引值为："+index);
}
public static int search(int[] arr, int num) {
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (num==arr[i]) {
return i;
}
}
return -1;
}
}
运行结果：
(2)折半查找
import java.util.Scanner;
/*
* 折半查找必须查找的是有序数组
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr={1,3,5,8,10,16,20,33,45,67,78,88,100};
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数字：");
int num=sc.nextInt();
int index=binary(arr,num);
System.out.println("你所查找的数字对应的索引值为："+index);
}
public static int binary(int[] arr, int num) {
int count=0;
int index=-1;
int start=0;
int end=arr.length-1;
while (start<=end) {
count++;
int mid=(start+end)/2;
if (arr[mid]==num) {
index=mid;
System.out.println("折半查找了"+count+"次");
break;
}
else if (num>arr[mid]) {
start=mid+1;
}
else if (num<arr[mid]) {
end=mid-1;
}
}
return index;
}
}
运行结果：
三、二维数组
(一)概述：二维数组其实就是一个元素为一维数组的数组。
(二)格式：
1. 格式1
格式：数据类型[][] 变量名 = new 数据类型[m]
;
解释：m表示这个二维数组有多少个一维数组，n表示每一个一维数组的元素个数
举例：int[][] arr = new int[3][2];
①定义了一个二维数组arr
②这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
③每个一维数组有2个元素，可以通过arr[m]
来获取，表示获取第m+1个一维数组的第n+1个元素
2. 格式2
格式：数据类型[][] 变量名 = new 数据类型[m][];
解释：m表示这个二维数组有多少个一维数组，这种格式没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3]
arr[2] = new int[1];
3. 格式3
格式：数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：int[][] arr = {{1,2,3},{4,5},{6}};
(三)二维数组练习
1. 二维数组遍历
class Array2Print{
public static void main(String[] args){
int[][] arr={{1,2,3},{4,5},{7}};
array2Print(arr);
}
public static void array2Print(int[][] arr){
for (int m=0;m<arr.length ;m++ ){
for (int n=0;n<arr[m].length ;n++ ){
System.out.println(arr[m]
);
}
}
}
}
运行结果：
2. 公司年销售额求和，某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
class Array2Sum{
public static void main(String[] args){
int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum=array2Sum(arr);
System.out.println("年度总销售额为："+sum+"万元");
}
public static int array2Sum(int[][] arr){
int sum=0;
for (int m=0;m<arr.length ;m++ ){
for (int n=0;n<arr[m].length ;n++ ){
sum+=arr[m]
;
}
}
return sum;
}
}
运行结果：
3. 打印杨辉三角形(行数可以键盘录入)
import java.util.Scanner;
class YangHuiSanJiaoPrint{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要打印的杨辉三角色行数：");
int row=sc.nextInt();
if (row<=0){
System.out.println("没有这样的行数");
}else{
int[][] arr=new int[row][];
System.out.println("你所输入的行数对应的杨辉三角为：");
arrayPrint(arr);
}
}
public static void arrayPrint(int[][] arr){
//遍历二维数组的第一层
for (int m=0;m<arr.length ;m++ ){
//初始化第二层数组的大小,即一维数组的长度
arr[m]=new int[m+1];
for (int n=0;n<m+1;n++ ){
//将两侧的数组元素赋值为1
if (m==0||n==0||n==m){
arr[m]
=1;
}
else{
//除两侧外其他数的计算
arr[m]
=arr[m-1]
+arr[m-1][n-1];
}
System.out.print(arr[m]
+"\t");
}
System.out.println();
System.out.println();
}
}
}
运行结果：
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
一、方法
(一)方法的定义及格式
定义：完成特定功能的代码块
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}
(二)方法格式的解释说明
修饰符：比较多，目前public static
返回值类型：用于限定返回值的数据类型
方法名：一个名称，为了方便我们调用方法
参数类型：限定调用方法时传入参数的数据类型
参数名：是一个变量，接收调用方法时传入的参数
方法体：完成功能的代码
return 结束方法以及返回方法指定类型的值
返回值：程序被return带回的结果，返回给调用者
(三)如何写一个方法呢?
两个明确
明确返回值类型
明确参数列表：明确有几个参数，以及参数的类型
(四)方法的注意事项
1. 方法不调用不执行
2. 方法与方法是平级关系，不能嵌套定义
3. 方法定义的时候参数之间用逗号隔开
4. 方法调用的时候不用在传递数据类型
5. 如果方法有明确的返回值，一定要有return带回一个值
(五)方法调用
1. 有明确返回值的方法调用(必须使用return返回，结束方法)
单独调用，没有意义，比如：add(3,9);
输出调用，有意义，但是不够好，因为不一定非要把结果输出，比如：
System.out.println(add(3,9));
赋值调用，推荐方式，比如：int c = add(3,9);
有明确返回值的方法练习：
①键盘录入三个数据，返回三个数中的最大值(If 嵌套实现,临时变量实现)
import java.util.Scanner;
class FunctionGetMax1{
public static void main(String[] args){
//创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数");
//定义变量，接收数据
int num1 = sc.nextInt();
System.out.println("请输入第二个数");
int num2 = sc.nextInt();
System.out.println("请输入第三个数");
int num3 = sc.nextInt();
int max = getMax(num1,num2,num3);
System.out.println("三个数中的最大值为："+max);
}
public static int getMax(int num1,int num2, int num3){
//定义临时变量，保存结果
int max = 0;
if (num1 > num2){
if (num1 > num3){
max = num1;
}
}
else if (num2 > num3){
max = num2;
}
else max = num3;
return max;
}
}
运行结果：
2. 没有明确返回值的方法调用(return可以省略)
其实就是void类型方法的调用
只能单独调用
没有明确返回值(返回值为void类型)的方法练习:
①键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
import java.util.Scanner;
class MulList{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据n(1<=n<=9)");
int x=sc.nextInt();
nineList(x);
}
public static void nineList(int i){
int count;
//输出行
for (int m=1;m<=i ;m++ ){
//输出列
for (int n=1;n<=m ;n++ ){
count=m*n;
System.out.print(n+"*"+m+"="+count+"\t");
}
System.out.println();
}
}
}
运行结果：
(六)方法重载
1. 方法重载概述：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2. 方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
方法重载练习：
①比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
class Load{
public static void main(String[] args){
byte b1 = 1;
byte b2 = 2;
short s1 = 1;
short s2 = 1;
int i1 = 3;
int i2 = 2;
long l1 = 4L;
long l2 = 4L;
load(b1,b2);
load(s1,s2);
load(i1,i2);
load(l1,l2);
}
public static void load(byte b1,byte b2 ){
String s = (b1==b2)?"相等" : "不相等";
System.out.println("这两个byte类型数" + s);
}
public static void load(short s1,short s2 ){
String s = (s1==s2)?"相等" : "不相等";
System.out.println("这两个short类型数" + s);
}
public static void load(int i1,int i2 ){
String s = (i1==i2)?"相等" : "不相等";
System.out.println("这两个int类型数" + s);
}
public static void load(long l1,long l2 ){
String s = (l1==l2)?"相等" : "不相等";
System.out.println("这两个long类型数" + s);
}
}
运行结果：
二、数组
(一)数组概念：
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
(二)数组特点:
1.能够装多个元素.
2.元素类型必须是同一类型
(三)数组定义格式：
格式1：数据类型[] 数组名;
举例：int[] arr ;
格式2：数据类型 数组名[];
举例：int arr[];
(四)数组初始化概述：
Java中的数组必须先初始化，然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
(五)数组的初始化方式
1. 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
(1)格式：数据类型[] 数组名 = new 数据类型[数组长度];
(2)数组长度其实就是数组中元素的个数。
举例：int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
2. 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
(1)格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：int[] arr = new int[]{1,2,3};
这种写法的简化的写法：int[] arr = {1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
(六)Java中的内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈：存储局部变量
堆：存储new出来的东西
方法区(面向对象)
本地方法区 (和系统相关)
寄存器 (给CPU使用)
(七)数组操作常见的两个小问题
1. 数组索引越界
ArrayIndexOutOfBoundsException：访问到了数组中的不存在的索引时发生。
2. 空指针异常
NullPointerException：数组引用没有指向实体，却在操作实体中的元素时。
(八)数组基本操作
1. 数组遍历(依次输出数组中的每一个元素)
class ArrayPrint{
public static void main(String[] args){
//定义一个数组
int[] arr = {11,22,33,44,55};
printArray(arr);
}
public static void printArray(int[] arr){
for (int x=0; x<arr.length; x++){
System.out.println(arr[x]);
}
}
}
运行结果：
2. 数组获取最值(获取数组中的最大值最小值)
class ArrayGet{
public static void main(String[] args){
int[] arr={99,1,3,5,8,33,23,89};
int min=getMin(arr);
System.out.println("数组中的最小值为："+min);
int max=getMax(arr);
System.out.println("数组中的最大值为："+max);
}
public static int getMin(int[] arr){
//定义变量，存储结果
int min=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (min>arr[i]){
min=arr[i];
}
}
return min;
}
public static int getMax(int[] arr){
int max=arr[0];
for (int i=1;i<arr.length ;i++ ){
if (max<arr[i]){
max=arr[i];
}
}
return max;
}
}
运行结果：
3. 数组元素逆序 (就是把元素对调)
class ArrayDuiDiao{
public static void main(String[] args){
int[] arr={11,22,33,44,55};
//反转前
display(arr);
//互换
huHuan(arr);
//反转后
display(arr);
}
public static void huHuan(int[] arr){
int start=0;
int end=arr.length-1;
while (start<end){
int t=arr[start];
arr[start]=arr[end];
arr[end]=t;
start++;
end--;
}
}
public static void display(int[] arr){
for (int i=0;i<arr.length ;i++ ){
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
运行结果：
4. 数组查表法(根据键盘录入索引,查找对应星期)
import java.util.Scanner;
class ArraySelect{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的星期。。。");
int week=sc.nextInt();
String[] arr={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
String a=getWeek(week,arr);
System.out.println("你查询的是："+ a);
}
public static String getWeek(int x,String[] arr){
if(x>0&&x<8){
return arr[x-1];
}
return null;
}
}
运行结果：
5. 数组元素查找(查找指定元素第一次在数组中出现的索引)
import java.util.Scanner;
class ArrayIedex{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要查询的元素：");
int n=sc.nextInt();
int[] arr={3,44,55,32,12,66,89,76,43,3,53,99,100,10,20,30};
int index=getIndex(n,arr);
System.out.println("指定元素的索引为："+index);
}
public static int getIndex(int num,int[] arr){
int index=-1;
for (int i=0;i<arr.length ;i++ ){
if (num==arr[i]){
index=i;
break;
}
}
return index;
}
}
运行结果：
(九)数组高级操作
1. 数组排序
(1)选择排序
package high_operate;
public class SelectSort {
public static void main(String[] args) {
int[] arr={2,5,6,19,9,0,1,3,8,7};
System.out.println("选择排序前：");
printArray(arr);
System.out.println("选择排序后：");
select(arr);
printArray(arr);
}
//选择排序
public static void select(int[] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = i+1; j < arr.length; j++) {
if (arr[i]>arr[j]) {
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (i!=arr.length-1) {
System.out.print(arr[i]+",");
}
else System.out.println(arr[i]+"]");
}
}
}
运行结果：
(2)冒泡排序
package high_operate;
public class BubbleSort {
public static void main(String[] args) {
int[] arr={7,5,3,2,65,77,43,12};
System.out.println("冒泡排序前：");
printArray(arr);
System.out.println("冒泡排序后：");
bubble(arr);
printArray(arr);
}
//冒泡排序
public static void bubble(int[] arr){
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if (arr[j]>arr[j+1]) {
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (i!=arr.length-1) {
System.out.print(arr[i]+",");
}
else System.out.println(arr[i]+"]");
}
}
}
运行结果：
2.数组查找
(1)基本查找
package high_operate;
import java.util.Scanner;
public class BasicSearch {
public static void main(String[] args) {
int[] arr={23,13,44,55,3,2,90,23,7,5};
//创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数字：");
int num=sc.nextInt();
int index=search(arr,num);
System.out.println("你所查找数字的索引值为："+index);
}
public static int search(int[] arr, int num) {
//遍历数组
for (int i = 0; i < arr.length; i++) {
if (num==arr[i]) {
return i;
}
}
return -1;
}
}
运行结果：
(2)折半查找
import java.util.Scanner;
/*
* 折半查找必须查找的是有序数组
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr={1,3,5,8,10,16,20,33,45,67,78,88,100};
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查找的数字：");
int num=sc.nextInt();
int index=binary(arr,num);
System.out.println("你所查找的数字对应的索引值为："+index);
}
public static int binary(int[] arr, int num) {
int count=0;
int index=-1;
int start=0;
int end=arr.length-1;
while (start<=end) {
count++;
int mid=(start+end)/2;
if (arr[mid]==num) {
index=mid;
System.out.println("折半查找了"+count+"次");
break;
}
else if (num>arr[mid]) {
start=mid+1;
}
else if (num<arr[mid]) {
end=mid-1;
}
}
return index;
}
}
运行结果：
三、二维数组
(一)概述：二维数组其实就是一个元素为一维数组的数组。
(二)格式：
1. 格式1
格式：数据类型[][] 变量名 = new 数据类型[m]
;
解释：m表示这个二维数组有多少个一维数组，n表示每一个一维数组的元素个数
举例：int[][] arr = new int[3][2];
①定义了一个二维数组arr
②这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
③每个一维数组有2个元素，可以通过arr[m]
来获取，表示获取第m+1个一维数组的第n+1个元素
2. 格式2
格式：数据类型[][] 变量名 = new 数据类型[m][];
解释：m表示这个二维数组有多少个一维数组，这种格式没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3]
arr[2] = new int[1];
3. 格式3
格式：数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：int[][] arr = {{1,2,3},{4,5},{6}};
(三)二维数组练习
1. 二维数组遍历
class Array2Print{
public static void main(String[] args){
int[][] arr={{1,2,3},{4,5},{7}};
array2Print(arr);
}
public static void array2Print(int[][] arr){
for (int m=0;m<arr.length ;m++ ){
for (int n=0;n<arr[m].length ;n++ ){
System.out.println(arr[m]
);
}
}
}
}
运行结果：
2. 公司年销售额求和，某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
class Array2Sum{
public static void main(String[] args){
int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum=array2Sum(arr);
System.out.println("年度总销售额为："+sum+"万元");
}
public static int array2Sum(int[][] arr){
int sum=0;
for (int m=0;m<arr.length ;m++ ){
for (int n=0;n<arr[m].length ;n++ ){
sum+=arr[m]
;
}
}
return sum;
}
}
运行结果：
3. 打印杨辉三角形(行数可以键盘录入)
import java.util.Scanner;
class YangHuiSanJiaoPrint{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要打印的杨辉三角色行数：");
int row=sc.nextInt();
if (row<=0){
System.out.println("没有这样的行数");
}else{
int[][] arr=new int[row][];
System.out.println("你所输入的行数对应的杨辉三角为：");
arrayPrint(arr);
}
}
public static void arrayPrint(int[][] arr){
//遍历二维数组的第一层
for (int m=0;m<arr.length ;m++ ){
//初始化第二层数组的大小,即一维数组的长度
arr[m]=new int[m+1];
for (int n=0;n<m+1;n++ ){
//将两侧的数组元素赋值为1
if (m==0||n==0||n==m){
arr[m]
=1;
}
else{
//除两侧外其他数的计算
arr[m]
=arr[m-1]
+arr[m-1][n-1];
}
System.out.print(arr[m]
+"\t");
}
System.out.println();
System.out.println();
}
}
}
运行结果：
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员——Java基础---多线程
- Android面试题集锦
- 黑马程序员——多态
- 黑马程序员——组合与super关键字
- [程序员面试金典]1001.字符串变换
- 程序员装逼指南 （转）
- 黑马程序员——继承
- [程序员面试金典]1002.下一个较大元素
- 黑马程序员——self使用
- 黑马程序员——Java基础---常用类，基本类型包装类，正则表达式
- 【黑马程序员】protocol的概念及基本使用
- 黑马程序员——Java基础---IO、File类、Properties类、打印流、序列流（合并流）
- 黑马程序员——类方法与self关键字
- 码农成长篇——新员工怎样快速脱颖而出
- 黑马程序员 oc随记 协议与代理模式
- 程序员扩大影响力之如何写博客
- 黑马程序员
- 黑马程序员——弱语法与类方法
- 黑马程序员——封装
- 高效程序员的狂暴之路