总结+数组

最新推荐文章于 2024-07-19 17:37:28 发布

03lx

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量146

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/m0_69038398/article/details/130073343

版权

1.算术运算符中 + 的用法

加法运算：数值+数值数值+字符

int a=10;
int b=5;
System.out.println(a+b);  //15  数值+数值-->加法运算

char c='c';
System.out.println(a+c);  //109  数值+字符-->加法运算  char在参与运算时,上升为int型 'c'-->99

字符串连接：字符串+字符串 字符串+数值

String d="a";
System.out.println(b+d);  //5a  字符串+数值-->连接
int i=1;
int j=2;
int k=3;
System.out.println(""+i+j+k);  //123  字符串(字符串可以为空)+数值-->连接

String s="l";
String sr="x";
System.out.println(s+sr);  //lx  字符串+字符串-->连接

2.条件运算符

(条件表达式) ?表达式1 :表达式2

注意：条件运算符和if-else语句用法很相似，不同的是条件运算符必须有返回值。在方法中使用时，需要定义一个和返回值数据类型相同的变量，用于接收返回值

int s=80;
String sr=(s>=60)?"及格" :"不及格";
System.out.println(sr);  //及格

int a=6;
int b=9;
int max=(a>b) ?a :b;  //返回最大值
System.out.println(max);  //9

3.charAt(int index)方法

返回指定索引位置的char值

Scanner scan=new Scanner(System.in);
char c=' ';
c=scan.next().charAt(0);  //识别用户所输入的字符并读入到程序中

4.break与continue用法

作用范围：break可以用于循环语句和switch-case语句中

continue只能用于循环语句中

且循环语句中，break在满足条件时，会终止其所在的整个循环，continue只是终止本次循环，还会进行下一次循环。

for(int i=0;i<6;i++){
            if(i==5){
                break; //终止整个循环
            }
System.out.print(i+" ");  //0 1 2 3 4
        }

for(int i=0;i<10;i++){
            if(i==5){
                continue; //终止本次循环
            }
System.out.print(i+" ");  //0 1 2 3 4 6 7 8 9

在循环嵌套语句中，如果在内层循环中使用break,则在满足条件时，break会终止整个内层循环，外层循环仍会继续执行，若要终止外层循环，可在外层循环添加标签。

int i,j;
for(i=0;i<3;i++){
    for(j=0;j<5;j++){
        if(j==4){
            break;
        }
        System.out.print(j+" ");
    }
    System.out.println();
}  //0 1 2 3
     0 1 2 3
     0 1 2 3
         
int i,j;
        labal:for(i=0;i<3;i++){
            for(j=0;j<5;j++){
                if(j==4){
                    break labal;
                }
                System.out.print(j+" ");
            }
            System.out.println();
        }  //0 1 2 3

switch语句中，如果没有加break,符合条件的语句块，则从满足条件的对应的case语句开始执行，在执行完该语句后继续执行其后的语句块，直到switch结构结束。

5.方法

java中的方法相当于c语言中的函数，都是用于解决某一问题而编写的代码集合。如main方法是主方法，在c语言中main函数，都是用来启动程序的。

方法的定义：

访问权限修饰符(public、private) 其他修饰符(static等) 返回值类型(int) 方法名 (参数类型参数名){

方法体}

关键字void表示方法无返回值，方法可以无返回值，也可以无参数

public static void hello(){
        System.out.println("你好");
    }  //hello方法无参数，无返回值

hello();  //使用 方法名();直接调用该方法，在其他类中调用时，要加上方法所在的类的类名进行调用，即 类名.方法名();

public static void main(String[] args){    
    String name="张三";  //声明两个与方法参数相同数据类型的变量，并赋初值
    int age=20;
    hello(name,age);  //在该类中直接调用hello方法
}

//创建一个无返回值，两个参数的hello方法
public static void hello(String name,int age){
        System.out.println("你好,"+name+" 年龄："+age);
} 
//结果：你好，张三 年龄：20

public static void main(String[] args) {
        int a=5;
        int b=3;
        int m=max(a,b);  //定义一个int变量用于接受max方法的返回值
        System.out.println("最大值为："+m);
}

//定义了一个两参数，有int型返回值的max方法
public static int max(int a,int b){
        int max=(a>b) ?a:b;
        return max;  //return返回max,终止方法
}
//结果：最大值为：5

数组

一维数组

定义：数组是一个存储相同类型数据的容器，可以存储多个值，所存储的数据在内存空间中的地址是连续的

声明：

int [] a,b; 声明int型数组a和数组b

int a[],b; 声明int型数组a和int型变量b(此种声明方式不建议)

创建：

1>.int[] a=new int[5]; 创建一个长度为5的数组a

int[] a表示声明了一个int型数组a,new int[5]表示创建了一个容量为5的连续内存空间

int [] x=new int[5];
System.out.println(x);  //输出数组在内存中的地址
System.out.println(Arrays.toString(x)); 
//toString()方法将数组转换为字符串输出  
//未对数组进行赋值时，int型数组中每个元素默认值为0，float型数组元素默认值0.0，String型默认为null
//结果：[0,0,0,0,0]

2>.int[] b=new int[]{1,2,3,4}; 创建一个长度为4的数组b,并为其赋值

int[] y={1,2,3,4,5};  //直接声明数组y并为其赋值
System.out.println(Arrays.toString(y));  //[1,2,3,4,5]  
String []sr=new String[]{"a","b","aa","bb"};
System.out.println(Arrays.toString(sr));  //[a,b,aa,bb]

访问：查看(遍历)数组中某一元素，对指定位置元素进行赋值

int[] a=new int[]{1,2,3,4,5};
        //        0 1 2 3 4
        System.out.println(a[0]);  //1
        a[0]=6;  //对数组中第一个元素进行赋值
        System.out.println(a[0]);  //6
        System.out.println(a.length); // 5 输出数组的长度

数组索引(也叫数组下标，数组标号)：是对数组中每个元素进行编号，从0开始到数组长度-1(数组名.length-1)，通过编号便于对数组元素进行遍历和赋值

注意：每个数组的索引都是从0开始，直到数组长度-1，即最大编号为数组长度-1；在使用时注意数组索引不能超出范围

遍历：

for循环

int[] a={1,2,3,4,5,6};
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
       }

增强for循环：定义一个与数组数据类型相同的变量，遍历数组中的每一个元素并依次将其赋给变量，最后输出变量

for(数据类型变量名：数组名){

System.out.println(变量); }

int[] a={2,0,0,2,6,6};
        for(int t:a) {
            System.out.print(t+" ");
        }  //2 0 0 2 6 6

二维数组

声明：

int[][] [] [] a;

int a[] []; 不建议使用此种方法声明数组，容易混淆

创建：

1>.int [] [] a=new int[3] [4]; 创建一个二维数组a,[3]表示二维数组的长度为3，[4]表示二维数组中每个一维数组的长度为4

2>.int [] [] b=new int[3] []; 创建一个长度为3的二维数组，但未确定二维数组中一维数组的长度。可以创建3个长度不同的一维数组将其赋给二维数组，这样数组b中每个一维数组的长度就是不同的。

int[][] a=new int[3][];  //a={null,null,null};
int[] b={1,2,3,4,5};
int[] c={1,2,3};
int[] d={1,2,3,4};
a[0]=b;
a[1]=c;
a[2]=d;
/*
a=1,2,3,4,5
  1,2,3
  1,2,3,4
*/

//声明数组并进行赋值
int[][] sz=new int[][]{{2,0,0,1,6,1,5},{2,0,0,2,6,6}};
int[][] sz={{2,0,0,1,6,1,5},{2,0,0,2,6,6}};

访问与遍历：

int[][] c=new int[3][4];
System.out.println(c[1][2]);  //0
c[1][2]=3;  //对二维数组中元素进行赋值
System.out.println(c[1][2]);  //3

for(int i=0;i<c.length;i++){  //遍历数组c
    for(int j=0;j<c[i].length;j++){
        System.out.print(c[i][j]+" ");
    }
    System.out.println();
}
/*c=0,0,0,0
    0,0,3,0
    0,0,0,0
*/

排序

冒泡排序

主要思想：将两个相邻的元素比较大小，将较大的元素向后移动，较小的元素向前移动

int[] a={5,4,3,2,1};
        for(int i=0;i<a.length-1;i++){  //控制总的趟数
            for(int j=0;j<a.length-1;j++){ 
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));  //[1, 2, 3, 4, 5]

选择排序

主要思想：从第一个元素开始依次和后面的每一个元素进行比较，将较小元素与当前元素进行交换

int [] a={3,2,1,5,4};
        for(int i=0;i<a.length-1;i++){  //循环到数组的倒数第二个元素
            for(int j=i+1;j<a.length;j++){  //比较到最后一个元素
                if(a[i]>a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));  //[1, 2, 3, 4, 5]

优化选择排序

从第一个元素开始依次和其后面的元素进行比较，若被比较元素小于当前元素，则记录该元素的下标，使用该元素与剩余元素继续比较，将最小元素与第一个元素进行交换，并依次用第二个元素与其后元素比较大小。

int [] a={3,2,1,5,4};
        for(int i=0;i<a.length-1;i++){
            int index=i;
            for(int j=i+1;j<a.length;j++){
                if(a[index]>a[j]){  //继续将较小的元素与之后的元素进行比较
                    index=j;  //记录较小元素的下标
                }
            }
            int temp=a[i];  
            a[i]=a[index];
            a[index]=temp;  //将一轮循环中最小元素与第i个元素进行交换
        }
        System.out.println(Arrays.toString(a));