java学习过程（基础篇）

小菜日记^_^
已于 2024-01-03 10:19:04 修改
阅读量445
点赞数 14
分类专栏： Java总结文章标签： java 学习开发语言
于 2023-12-26 11:09:27 首次发布
本文链接：https://blog.csdn.net/m0_57957187/article/details/135217012
版权
Java总结专栏收录该内容
22 篇文章 0 订阅
订阅专栏
java学习基础篇，一些基本的语法知识，掌握基础语法，可以快速入门；后续会继续发布，面向对象、io、多线程、以及mysql和ssm、springboot框架等笔记。以下代码可以直接复制到idea中运行，便于理解和练习；
//基础语法：

//一个项目中有多个模块，一个模块中有多个包
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;
public class java_study_0001 {
    //双斜线单行注释；
    /*
    多行注释
     */
    public static void main(String[] args){
//        System.out.println("hello\thello");//此处的\t代表空格
        //基本数据类型：
//        byte b=10;//byte 8位
//        short c=10;//short 16位
//        int d =10;//int 32位
//        long f=10;//long 64位
//        float a=1.0f;//这里需要加f不然会报错，因为小数点数据默认是双精度double类型
//        double e=1.0;
//        char chr='a';//16位，只能一个字符如果是'10'会报错
//        boolean a=true;//布尔类型
        //引用数据类型：主要是一些类、接口、数组，引用类型变量中存储的是地址，对应的地址存储数据；
//        String str="asd";

        //TODO 类型转换：将小的赋值给大的是可以的，但是反过来是不行的，可以通过强制转换来实现将大的赋值给小的,如下：
        //从小到大：byte--short--int--long--float--double
//        double d=2;
//        int i=(int) d;
        //TODO String类型的使用
        //String类是引用数据类型俗称字符串、用" "来创建，可以包含0、1、多个字符、与基本类型只能进行连接运算，用+
//        int i=10;
//        String str="hello";
//        boolean a=true;
//        System.out.println(str+i+a);
//        //System.out.println(a+i+str);//如果是这样会报错，boolean不能与基本数据类型进行运算
        //将可转化的String类型转化为int类型：使用Integer
//        String str=10+"";
//        int num1=Integer.parseInt(str);
//        System.out.println(num1);
        //赋值运算符：
        //连续赋值：
//        int a=10,b=20;
//        System.out.println(a+" "+b);

        //对于二元运算符，也就是加减乘除这种需要两个数值进行运算的   还有 %取模运算
        //TODO 算数表达式= 元素1 二元运算符 元素2
        //注意这个表达式的结果的数据类型是两个元素中类型最大的那个，如下：     最小的数据类型是int类型，例如byte类型不能进行二元运算
//        System.out.println(1/2);//这里需要注意得到的结果是0，因为是int类型。改成1.0/2即可
        //char类型进行运算的时候是直接转化为ascll码然后再进行运算：
//        char a='a';
//        char b='b';
//        System.out.println(a);
//        System.out.println(1+a);
//        System.out.println(a+b);

        //TODO 各种进制的转换
//        int num1=101;//十进制
//        int num2=0b10;//二进制
//        int num3=023;//八进制
//        int num4=0X23a;//十六进制
//        //输出后都转化为十进制
//        System.out.println(num1);
//        System.out.println(num2);
//        System.out.println(num3);
//        System.out.println(num4);

        //TODO 一元运算符：不会改变变量类型
//        int i=1;
//        int j=i++;//int j=++i;
//        System.out.println("i="+i+",j="+j);

        //TODO 复合赋值运算符 += /= *= %=  注意此处不会改变数据类型，例子如下：byte、short、char之间做运算得到的结果是int类型
//        byte a=10;
//        a=(byte) (a+10);//此处是二元运算，得到的结果的类型是按照最大类型，a是byte类型，是小转大，因此需要强制转换否则会报错。
//        a+=10;//利用复合赋值运算符不会改变数据类型，a仍然是byte类型
//        int m=1;
//        m*=0.1;
//        System.out.println(m);//输出是0，因为是还是int型
        //如果是m=m*0.1会报错，因为0.1是double类型再赋值给m相当于将小类型赋值给大类型

        //TODO 关系运算符 == != >= <=

        //TODO 逻辑运算符 &（两个都是true才是true，如果第一个是false依然会继续执行第二个）、&&（两个都是true菜蔬true，第一个是false不执行第二个，直接返回false）、| ||，逻辑非运算：！，true改为false，false改为true
//        int num1=1,num2=2;
//        if(num1>0&&num2>3){
//            System.out.println("nihao");
//        }
//        int i=1;
//        boolean result=i==1;
//        System.out.println(result);
//        System.out.println(!result);

        //TODO 三元运算符 （条件表达式1）？（任意表达式1）：（任意表达式2）,三元运算符的都能转化为if-else，但是三元运算符效率高一些
//        int i=1;
//        int a=6,b=3;
//        int k=(i>=1)? a+b:a-b;
//        System.out.println(k);
        //TODO 位运算：<<逻辑左移，>>逻辑右移，负数右移一位补1，正数右移一位补0，与运算&：都是1才为1，异或运算^:相异为1相同为0，取反运算~：包括符号位取反
//        System.out.println(~9);
//        System.out.println(~-10);

        //TODO 分支结构：如果if()后面不带大括号{}，默认只涵盖后面一条语句，如果要判断一个数大于50小于90要写成if(num>50&&num<90){},不能写成if(50<num<90){}
//        int i=20;
//        if(i==10){
//            System.out.println("分支一");
//        }else if(i==20){
//            System.out.println("分支二");
//        }else{
//            System.out.println("分支三");
//        }
        //switch-case:
//        String num="11";
//        switch (num){
//            case "a":
//                System.out.println("hello");
//            case "11":
//                System.out.println("hello1");
//            case "num":
//                System.out.println("nihao");
//            default:
//                System.out.println("dajiahao");
//        }
        //TODO 使用Scanner类来从键盘输入数据,先导包，import java.utile.Scanner
//        Scanner scan=new Scanner(System.in);
//        String a=scan.next();
        //TODO 获取随机数，使用random方法，会返回一个[0,1)之间double类型的随机数，如果想要进行设置范围的话，需要进行更改：(要一步步去分析)
//        //获取[0,100]随机数:
//        double num=Math.random();
//        System.out.println(num);
//        int num2=(int)(Math.random()*101);
//        System.out.println(num2);
//        //获取[1,100]随机数：
//        int num3=(int)(Math.random()*100+1);
//        System.out.println(num3);
//        //重要：获取[a,b]范围的随机数：(int)(Math.random()*(b-a+1))+a
        //TODO 循环结构：for,while,do while
        //for:
//        int sum=0;
//        int sum_num=0;
//        for(int i=1;i<=100;i++){
//            if(i%2==0){
//                sum++;
//                sum_num+=i;
//                System.out.println(i);
//            }
//        }
//        System.out.println("1-100偶数的个数为"+sum+",1-100偶数的和为"+sum_num);
        //while:
//        int i=1,count=0,sum=0;
//        while(i<=100){
//            if(i%2==0){
//                count++;
//                sum+=i;
//                System.out.println(i);
//            }
//            i++;
//        }
//        System.out.println("1-100偶数的个数为"+count+",1-100偶数的和为"+sum);
        //do-while:
//        int i=1,count=0,sum=0;
//        do{
//            if(i%2==0){
//                count++;
//                sum+=i;
//                System.out.println(i);
//            }
//            i++;
//        }while(i<=100);
//        System.out.println("1-100偶数的个数为"+count+",1-100偶数的和为"+sum);
        //练习：atm存取款机器
//        int banlance=0;
//        Scanner scan=new Scanner(System.in);
//        while(true){
//            System.out.println("请输入您的操作：");
//            int input=scan.nextInt();
//            if(input==1){
//                System.out.println("请输入存款额数：");
//                banlance+=scan.nextInt();
//            }else if(input==2){
//                System.out.println("请输入取款额数：");
//                int money=scan.nextInt();
//                if(banlance>=money){
//                    banlance-=money;
//                }else{
//                    System.out.println("余额不足");
//                }
//
//            }else if(input==3){
//                System.out.println("您的余额为："+banlance);
//            }else if(input==4){
//                System.out.println("已退出");
//                break;
//            }
//        }
        //输出素数：
//        int j;
//        for(int i=2;i<=100;i++){
//            for (j=2;j<Math.sqrt(i);j++){
//                if(i%j==0){
//                    break;
//                }
//            }
//            if(j>=Math.sqrt(i)){
//                System.out.println(i);
//            }
//        }

        //TODO 数组：数组中的元素在内存中是依次紧密排列的，有序的。数组属于引用数据类型的变量，数组的元素可以是基本数据类型也可以是引用数据类型。数组一旦初始化，其长度就已经确定了，并且不能更改。
//        //数组的声明：
//        double[] prices;
//        //静态初始化：
//        //数组的初始化：
//        prices=new double[]{20.1,20.3,50.1};
//        //数组的初始化：
//        double[]num={20.0,20.1};//省略了new double[];
        //动态初始化：
        //数组的声明和初始化：
//        String[] foods=new String[4];
//        foods[0]="水饺";
//        foods[1]="冬瓜";
//        foods[2]="火锅";
//        foods[3]="烤串";
//        System.out.println(foods[0]);
//        //数组的长度：.length
//        System.out.println(prices.length);
//        System.out.println(num.length);
//        System.out.println(foods.length);
//        //遍历数组：
//        for(int i=0;i< foods.length;i++){
//            System.out.println(foods[i]);
//        }
        //不同数据类型元素的数组默认值：
        /*byte,short int float double默认值为0
        char 默认值为0不是‘0’
        boolean 默认值为false
        引用数据类型以String类为代表，默认值为null*/

        //练习：
//        Scanner scan=new Scanner(System.in);
//        System.out.println("请输入学生人数：");
//        int count=scan.nextInt();
//        int[] students=new int[count];
//        int max=0;
//        for(int i=0;i<count;i++){
//            int score=scan.nextInt();
//            if(max<score){
//                max=score;
//            }
//            students[i]=score;
//        }
//        System.out.println("最高分为："+max);
//        for(int i=0;i<students.length;i++){
//            if(students[i]>90){
//                System.out.println("第"+(i+1)+"个学生的等级是A");
//            }else if(students[i]>80){
//                System.out.println("第"+(i+1)+"个学生的等级是B");
//            }else if(students[i]>70){
//                System.out.println("第"+(i+1)+"个学生的等级是C");
//            }else{
//                System.out.println("第"+(i+1)+"个学生的等级是D");
//            }
//        }
        //二维数组：
//        int[][]arr=new int[][]{{123,1,2},{3,14,45}};
//        int[][]arr1=new int[3][4];
//        double[][]arr2=new double[3][];
//        arr2[0]= new double[]{1.0, 2.0, 3.1};
//        arr2[1]=new double[4];
//        arr2[2]=new double[2];
//        System.out.println(arr[1]);//输出的是地址
//        System.out.println(arr[1][1]);
//        System.out.println(arr.length);
//        System.out.println(arr[0].length);
//        //遍历二维数组：
//        for(int i=0;i<arr2.length;i++){
//            for(int j=0;j<arr2[i].length;j++){
//                System.out.println(arr2[i][j]);
//            }
//        }

        //练习：数组元素反转
//        int[] arr=new int[]{1,2,3,4,5,6,7,8,9};
//        for(int i=0;i<arr.length/2;i++){
//            int temp=arr[i];
//            arr[i]=arr[arr.length-i-1];
//            arr[arr.length-i-1]=temp;
//        }
//        for (int i = 0; i < arr.length; i++) {
//            System.out.print(arr[i]+"\t");
//
//        }
//        //TODO 冒泡排序：
//        int[]arr=new int[]{1,4,3,5,2};
//        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 num=arr[j];
//                    arr[j]=arr[j+1];
//                    arr[j+1]=num;
//                }
//            }
//        }
//        for(int num:arr){
//            System.out.println(num);
//        }
//        //TODO Array工具类的使用：
//        //1.比较两个数组元素是否相同：Array.equals(arr1,arr2)
//        int[]arr1=new int[]{1,2,3,4,5};
//        int[]arr2=new int[]{1,2,3,4,5};
//        System.out.println(arr1==arr2);//此处用==其实是变量寸什么比较的什么，此处存的是地址
//        boolean one=Arrays.equals(arr1,arr2);//这个比较的才是内容，一个一个的比较
//        boolean nnn=Arrays.equals(arr1,0,5,arr2,0,5);//这个比较的是arr1和arr2前五个数相同不相同；
//        System.out.println(one);
//        System.out.println(nnn);
//        //2.输出数组元素信息：Arrays.toString(arr1)
//        System.out.println(Arrays.toString(arr1));//输出的是[1,2,3,4,5],带有框;
//        //3.将该数值填充到数组中，所有元素全部变成该数值：Arrays.fill(arr1,value)
//        Arrays.fill(arr1,10);
//        System.out.println(Arrays.toString(arr1));
//        //4.使用快速排序排序数组：Arrays.sort(arr1)：在原数组上更改
//        int[]arr3=new int[]{12,5,7,8,41,2,3,66,17};
//        int[]arr12=arr3.clone();//复制数组；对复制的数组进行排序
//        System.out.println(Arrays.toString(arr12));
//        Arrays.sort(arr12);
//        System.out.println(Arrays.toString(arr12));
//        //5.二分查找：Arrays.binarySearch(arr1,value):使用前提：当前数组必须是有序的！找到输出索引，没找到输出负数
//        int palce=Arrays.binarySearch(arr2,15);
//        System.out.println(palce);

        //TODO 字符串：上方也有一小部分字符串的使用，这里主要指的是更高级的用法；
//        char[]c={'a','中','国'};
//        String s=new String(c);
//        System.out.println(s);
//        byte[] b={-28,-72,-83,-27,-101,-67};
//        String s1=new String(b);//三个字节转为一个字符；
//        System.out.println(s1);
//        //转义字符\ 的使用
//        String s3= "\"";
//        System.out.println("\'");
//        System.out.println("a\tb");//空格
//        System.out.println("c\nd");//换行
//        System.out.println("e\\f");
          //TODO 字符串的比较：
//        String a="a";
//        String b="a";
//        String c="A";
//        //判断相等：
//        System.out.println(a.equals(b));//true
//        System.out.println(a.equals(c));//false
//        //如果想让大写的A与a相等的话，用到下面的方法：
//        System.out.println(a.equalsIgnoreCase(c));
//        //比较大小：如果i大于0则a>b,如果i小于0则a<b;如果i等于0，则a=b;此处比较的是acsii码值；
//        int i=a.compareTo(b);
//        System.out.println(i);
//        int j=a.compareTo(c);
//        System.out.println(j);
//        //忽略大小写的比较：
//        int n=a.compareToIgnoreCase(c);
//        System.out.println(n);

//        //TODO 截取字符串：substring方法，需要传两个参数，第一个参数是字符串的起始位置（包括），第二个参数是想要截取的终点位置（不包括），
//        // 两个参数都是索引；如果只传一个参数的话，代表的是从指定索引位置一直截取到最后一个字符；
//        String s="Hello World!";
//        String s1=s.substring(0,3);//从索引为0开始到索引为三结束，不包括三；
//        System.out.println(s1);
//        //如果想打印出来hello，可以直接使用如下方法：
//        String s2=s.substring(0,"Hello".length());
//        System.out.println(s2);
//        String s3=s.substring(0);
//        System.out.println(s3);
//
//        //TODO 字符串的分解：split方法:将字符串按照指定的规则分解成几个部分，返回的是数组：如下
//        String name="zhangsan,lisi,wangwu,zhaoliu";
//        String[]name1=name.split(",");
//        System.out.println(name1.length);
//        for(String n:name1){
//            System.out.println(n);
//        }
//
//        //TODO 去掉字符串的空格：trim方法，去掉的是首尾的空格：
//        String sss="   Hello World   ";
//        System.out.println(sss.trim());
//        System.out.println(sss);

//        //TODO 字符串的替换：replace方法将指定字符串全部替换；replaceAll方法：将指定的不同的字符串都进行替换
//        String s="Hello World World zhangsan";
//        String s1=s.replace("World","java");
//        System.out.println(s1);
//        System.out.println(s);
//        String s2=s.replaceAll("Hello|zhangsan","java");
//        System.out.println(s2);//将Hello和zhangsan都替换成java;
//        System.out.println(s);
        //TODO 字符串的大小写转换：
//        String s="Hello World";
//        //将字符串都转化为大写：
//        String s1=s.toUpperCase();
//        System.out.println(s1);
//        //将字符串都转化为小写：
//        String s2=s.toLowerCase();
//        System.out.println(s2);
//        //只想将首字母进行大写，可以用截取字符串然后进行转换再拼接：
//        String sss="user";
//        String sss1=sss.substring(0,1);
//        String sss2=sss.substring(1);
//        String sss3=sss1.toUpperCase()+sss2;
//        System.out.println(sss3);
//        //TODO 字符串的查找：
//        String s="Hello World";
//        //toCharArray方法可以直接将字符串转化为char类型数组
//        char[]arr=s.toCharArray();
//        System.out.println(arr[1]);
//        System.out.println(arr);//char数组可以直接打印输出
//        //charAt方法可以传递索引返回指定索引位置的元素：
//        System.out.println(s.charAt(1));
//        //indexOf方法可以传递字符串然后返回该字符串第一次所在索引位置；
//        System.out.println(s.indexOf("World"));
//        //lastIndexOf()方法是从末尾开始寻找：
//        String n="World Hello World";
//        System.out.println(n.indexOf("World"));
//        System.out.println(n.lastIndexOf("World"));

//        //TODO contains方法，字符串中是否包含指定的字符串：返回是boolean类型
        String s="Hello World";
        System.out.println(s.contains("Hello"));
//        //TODO startsWith()方法判断字符串是否以指定字符串开头：endsWith()方法判断字符串是否已指定字符串结尾：
//        String s="Hello World";
//        System.out.println(s.startsWith("World"));
//        System.out.println(s.startsWith("Hello"));
//
//        System.out.println(s.endsWith("World"));
//        System.out.println(s.endsWith("Hello"));
//        //TODO 判断字符串是否为空，空格其实是一个特殊的字符，所以看不到，但是不为空；返回boolean类型
//        String name=" ";
//        System.out.println(name.isEmpty());

//        //TODO StringBuilder的使用：以数组的形式存：
//        StringBuilder one=new StringBuilder();
//        one.append("abc");//此处的append方法可以随意添加，可以添加字符可以添加字符串；
//        System.out.println(one);
//        System.out.println(one.length());
//        one.reverse();//反转，在原字符串上进行操作；
//        System.out.println(one);
//        //插入操作：
//        one.insert(1,"d");
//        System.out.println(one);
    }
}
小菜日记^_^
关注
14
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
java学习过程（基础篇）

java学习基础篇，一些基本的语法知识，掌握基础语法，可以快速入门；后续会继续发布，面向对象、io、多线程、以及mysql和ssm、springboot框架等笔记。以下代码可以直接复制到idea中运行，便于理解和练习；
复制链接

扫一扫