Day3
1.方法的调用
直接调用:方法名(实参列表);
类名调用:类名.方法名(实参列表);
对象调用:对象.方法名(实参列表);(面向对象会使用)
类名调用:类名.方法名(实参列表);
对象调用:对象.方法名(实参列表);(面向对象会使用)
2.一维数组的静态初始化
数据类型[] 数组名={初值0,初值1,…,初值n};
eg:
int[] score={65,59,73,71,98,66}
eg:
int[] score={65,59,73,71,98,66}
3.遍历数组
1.方法一:
通过for循环获取数组元素的下标,然后遍历对应元素
例如:
for(int i=0;i<array.length;i++){
// 逐个遍历元素array[i]
}
例如:
for(int i=0;i<array.length;i++){
// 逐个遍历元素array[i]
}
2.方法2:
foreach输出
for(数据类型 变量名称:数组名称){
…
}
例如:
for(int x:array){
// x为当前正在遍历的数组元素
}
for(数据类型 变量名称:数组名称){
…
}
例如:
for(int x:array){
// x为当前正在遍历的数组元素
}
eg:package array;
public class ArrayDemo {
public static void main(String[] args) {
int[] a=new int[5];
a[2]=23;
a[4]=19;
System.out.println("遍历第一个数组:");
for(int i=0;i<a.length;i++){ // i充当了下标
System.out.print(a[i]+" ");
}
System.out.println();
int[] b={11,22,33,44,55,66}; // 直接给数组赋值
System.out.println("遍历第二个数组:");
for(int i=0;i<b.length;i++){ // i充当了下标
System.out.print(b[i]+" ");
}
System.out.println();
System.out.println("使用foreach方式遍历数组:");
for(int x:b){
System.out.print(x+" ");
}
System.out.println();
}
}
public class ArrayDemo {
public static void main(String[] args) {
int[] a=new int[5];
a[2]=23;
a[4]=19;
System.out.println("遍历第一个数组:");
for(int i=0;i<a.length;i++){ // i充当了下标
System.out.print(a[i]+" ");
}
System.out.println();
int[] b={11,22,33,44,55,66}; // 直接给数组赋值
System.out.println("遍历第二个数组:");
for(int i=0;i<b.length;i++){ // i充当了下标
System.out.print(b[i]+" ");
}
System.out.println();
System.out.println("使用foreach方式遍历数组:");
for(int x:b){
System.out.print(x+" ");
}
System.out.println();
}
}
//changearray;
eg:
package array;
public class MethodArray {
public static void main(String[] args) {
int[] a={23,12,999,88,78};
changeArray(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void changeArray(int[] a){
a[2]=666;
}
}
public class MethodArray {
public static void main(String[] args) {
int[] a={23,12,999,88,78};
changeArray(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void changeArray(int[] a){
a[2]=666;
}
}
Day4
1.数组拷贝
System类中有一个静态方法:
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
参数解释:
src: 源数组
srcPos: 源数组的起始位置
dest: 目标数组
destPos:目标数组的起始位置
length:拷贝的数组元素个数
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
参数解释:
src: 源数组
srcPos: 源数组的起始位置
dest: 目标数组
destPos:目标数组的起始位置
length:拷贝的数组元素个数
eg:
package copy;
public class ArrayCopy {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b={11,22,33,44,55,66,77,88,99};
System.arraycopy(a,1,b,4,3);
System.out.println("复制后的数组:");
for (int i = 0; i < b.length; i++) {
System.out.print(b[i]+" ");
}
}
public class ArrayCopy {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b={11,22,33,44,55,66,77,88,99};
System.arraycopy(a,1,b,4,3);
System.out.println("复制后的数组:");
for (int i = 0; i < b.length; i++) {
System.out.print(b[i]+" ");
}
}
}
2.三种排序:
(1).冒泡排序
共有n个数据,则需要进行n-1趟排序(可优化),每一趟排序都会通过“两两交换”的方式对数据进行比较,每一趟排序后都会将本趟排序的最大值“冒”到后面。
共有n个数据,则需要进行n-1趟排序(可优化),每一趟排序都会通过“两两交换”的方式对数据进行比较,每一趟排序后都会将本趟排序的最大值“冒”到后面。
eg:
package org.westos.homework;
public class BubbleSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
bubbleSort(a);
}
public static void bubbleSort(int[] a){
for (int i = 1; i <=a.length-1; i++) { // 外层循环控制比较的“趟数”
boolean flag=true;
for(int j=0;j<a.length-i;j++){ // j变量是数组的索引(下标),j也控制着当前趟的“两两比较”的次数
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag=false;
}
}
System.out.println("第"+i+"趟排序结果:");
for(int x:a){
System.out.print(x+" ");
}
System.out.println();
if(flag){ // 如果当前“趟”已经排号序,则不必进行下一趟的排序,直接跳出外层循环
break;
}
}
}
}
public class BubbleSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
bubbleSort(a);
}
public static void bubbleSort(int[] a){
for (int i = 1; i <=a.length-1; i++) { // 外层循环控制比较的“趟数”
boolean flag=true;
for(int j=0;j<a.length-i;j++){ // j变量是数组的索引(下标),j也控制着当前趟的“两两比较”的次数
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag=false;
}
}
System.out.println("第"+i+"趟排序结果:");
for(int x:a){
System.out.print(x+" ");
}
System.out.println();
if(flag){ // 如果当前“趟”已经排号序,则不必进行下一趟的排序,直接跳出外层循环
break;
}
}
}
}
(2).插入排序
对一个有n个元素的数据序列,排序需要进行n-1趟插入操作(可优化)。
第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。
第二趟插入将第3个元素插入前面的有序子序列,前面两个元素是有序的。
第n-1趟插入将第n个元素插入前面的有序子序列,前面n-1个元素是有序的。
对一个有n个元素的数据序列,排序需要进行n-1趟插入操作(可优化)。
第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。
第二趟插入将第3个元素插入前面的有序子序列,前面两个元素是有序的。
第n-1趟插入将第n个元素插入前面的有序子序列,前面n-1个元素是有序的。
eg:
package sort;
public class InsertSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
insertSort(a);
System.out.println("插入排序的结果:");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void insertSort(int[] a){
for (int i = 1; i <=a.length-1; i++) {
int data=a[i]; // 当前“指示灯数据”
int j=i-1; // 使用j变量记录“指示灯数据”的前一个数据的索引
while(j>=0 && data<a[j]){
a[j+1]=a[j]; // 后移“指示灯”数据前面的数据
j--;
}
a[j+1]=data;
}
}
}
public class InsertSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
insertSort(a);
System.out.println("插入排序的结果:");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void insertSort(int[] a){
for (int i = 1; i <=a.length-1; i++) {
int data=a[i]; // 当前“指示灯数据”
int j=i-1; // 使用j变量记录“指示灯数据”的前一个数据的索引
while(j>=0 && data<a[j]){
a[j+1]=a[j]; // 后移“指示灯”数据前面的数据
j--;
}
a[j+1]=data;
}
}
}
(3).快速排序
从待排序的数据序列中任取一个数据(如第一个数据)作为分界值,所有比它小的数据元素放到左边,所有比它大的数据元素放到它的右边。
接下来,对左右两个子序列按照上述方法进行递归排序,直到排序完成。
接下来,对左右两个子序列按照上述方法进行递归排序,直到排序完成。
eg:
package sort;
public class QuickSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
quickSort(a,0,a.length-1);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void quickSort(int[] array,int start,int end){
if(start>=end){
return; // 结束方法
}
int data=array[start]; // 将起始索引执行的值作为“分界值”
int i=start+1; // 记录向右移动的位置(“红军”)
int j=end; // 记录向左移动的位置("蓝军")
while(true){
while(i<=end && array[i]<data){
i++; // 索引右移
}
while(j>=start+1 && array[j]>data){
j--; // 索引左移
}
if(j>i){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}else{
break;
}
}
// “蓝军”与“分界值”交换位置
array[start]=array[j];
array[j]=data;
quickSort(array,start,j-1); // 递归调用完成“分界值”左边的排序
quickSort(array,j+1,end); // 递归调用完成“分界值”右边的排序
}
}
public class QuickSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
quickSort(a,0,a.length-1);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void quickSort(int[] array,int start,int end){
if(start>=end){
return; // 结束方法
}
int data=array[start]; // 将起始索引执行的值作为“分界值”
int i=start+1; // 记录向右移动的位置(“红军”)
int j=end; // 记录向左移动的位置("蓝军")
while(true){
while(i<=end && array[i]<data){
i++; // 索引右移
}
while(j>=start+1 && array[j]>data){
j--; // 索引左移
}
if(j>i){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}else{
break;
}
}
// “蓝军”与“分界值”交换位置
array[start]=array[j];
array[j]=data;
quickSort(array,start,j-1); // 递归调用完成“分界值”左边的排序
quickSort(array,j+1,end); // 递归调用完成“分界值”右边的排序
}
}
3:二维数组
二维数组的声明与实例化:
数据类型[][] 数组名称=new 数据类型[行的个数][列的个数];
注意:二维数组的length属性就是它所包含的“行的个数”。
二维数组访问具体元素的语法: 数组名称[行的索引][列的索引]
数据类型[][] 数组名称=new 数据类型[行的个数][列的个数];
注意:二维数组的length属性就是它所包含的“行的个数”。
二维数组访问具体元素的语法: 数组名称[行的索引][列的索引]
二维数组的静态初始化
数据类型[][] 数组名称={
{元素1,元素2,....},
{元素1,元素2,....},
...
};
数据类型[][] 数组名称={
{元素1,元素2,....},
{元素1,元素2,....},
...
};
eg1:
package twoarray;
public class InitialTwoArray {
public static void main(String[] args) {
String[][] array={
{"Apple","Orange","Banana"},
{"Dog","Cat"},
{"Phone","Machine","Book","Java","兵法"}
};
for(int i=0;i<array.length;i++){ // 循环行
for(int j=0;j<array[i].length;j++){ // 循环当前行(一维数组)的数据
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
public class InitialTwoArray {
public static void main(String[] args) {
String[][] array={
{"Apple","Orange","Banana"},
{"Dog","Cat"},
{"Phone","Machine","Book","Java","兵法"}
};
for(int i=0;i<array.length;i++){ // 循环行
for(int j=0;j<array[i].length;j++){ // 循环当前行(一维数组)的数据
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
eg2.
package twoarray;
public class TwoArrayDemo {
public static void main(String[] args) {
String[][] array=new String[4][3];
array[0][0]="风清扬";
array[0][1]="孙武";
array[0][2]="曼施坦因";
array[1][0]="马云";
array[1][1]="猪八戒";
array[2][0]="王健林";
array[2][1]="小王子";
array[3][2]="扫地僧";
for(int i=0;i<array.length;i++){ // 循环行
for(int j=0;j<array[i].length;j++){ // 循环当前行(一维数组)的数据
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
//注意问题:1.char数据类型在内存中是以整数存储的(范围是0~65535)。
每一个整数映射一个字符。
2.byte、short、char这三种变量一旦参与运算,则编译器
将运算的结果转换为int(因为编译器将参与运算的byte、short、char当作了int)。
eg:byte b1=1;
byte b2=2;
byte b3=(byte) (b1+b2);
3.当给byte、short、char变量以“直接常量”的方式赋值
时,只要这个“直接常量”没有超过这些数据类型的范围,
则编译器也是允许的。
每一个整数映射一个字符。
2.byte、short、char这三种变量一旦参与运算,则编译器
将运算的结果转换为int(因为编译器将参与运算的byte、short、char当作了int)。
eg:byte b1=1;
byte b2=2;
byte b3=(byte) (b1+b2);
3.当给byte、short、char变量以“直接常量”的方式赋值
时,只要这个“直接常量”没有超过这些数据类型的范围,
则编译器也是允许的。