变量

//byte表示数据类型，b表示变量名称，=表示赋值（把等号后面的值赋值给等号前面的变量b）
byte b=2;
b=3;//再次使用=号操作变量时，变量会被重新赋值
System.out.println(b);//打印变量b的值

short s=287;

int i=19837;

long l=198827376365L;//long类型的数据需要在数字最后加上标识小写l或者大写L
long a=1L;

float f=1.235645645664566f;//float类型的数据要在数字后边加上f
double d=12.2344456565767676767;
System.out.println(f);
System.out.println(d);

//boolean类型的值只有两个，要么是true，要么是false
//存储要么是肯定的，要么是否定的，这种答案
boolean flag=true;//true表示的，是真的
flag=false;//false表示否定的，是假的

char c='c';//char类型主要用来存储单字符，特别注意的是必须使用单引号

基础运算

    	int a=10;
        int b=20;
        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/b);//0,因为a和b都是int类型，所以结果也是int类型，取整后就是0
        float c=20;
        System.out.println(a/c);//0.5,如果计算中有任何一个数是float或者double，那么结果就小数
        int d=4;
        System.out.println(a%4);//余数是2
        System.out.println(d++);//打印结果，谁在前先执行谁,相当于下面两句,这句执行完后d=5
//        System.out.println(d);
////        d++;
        System.out.println(++d);//6,这一行相当于下面两行
//        d++;
//        System.out.println(d);
        int e=8;
        System.out.println(e--);//8
        System.out.println(--e);//6
        System.out.println(d==e);//true
        System.out.println(d!=e);//false
        System.out.println(d>e);//false
        System.out.println(d<e);//true
        System.out.println(d>=e);//true
        System.out.println(d<=e);//true

        int f=10,h=20,g=13;
        //&&的执行是如果第一个表达式能够决定整个表达式的结果时，则不会计算后面的表达式了
        //&是所有表达式都要去执行
        System.out.println(f>h&&h>g);//并且条件下，任何一个条件为false，则整个结果都为false
        System.out.println(f>h||h>g);//或者条件下，任何一个条件为true，则整个结果都为true
        System.out.println(!true);//false
        System.out.println(!(f>h||h>g));//false

string数据类型基础玩法

 //String是变量类型，name是变量名称，=表示赋值
        String name="沙陌";
        System.out.println(name);
        String s1="hahsjdjhahsdhggsdgggsfsffdwe";
        s1.length();//使用变量s1调用length()就可以得到字符串的长度
        System.out.println(s1.length());
        int age=30;
        //打印沙陌的姓名和年龄
        System.out.printf("姓名%s,年龄是%d",name,age);//这个打印不会换行
        System.out.println();
        System.out.println("姓名"+name+",年龄是"+age);//纯拼接

        String s2="码同学";
        String s3=" 码同学         ";
        System.out.println(s2);
        System.out.println(s3.trim());//表示去掉s3这个变量两端的空格

        String s4="abcdefg";
        //目标是从s4中得到cde
        System.out.println(s4.substring(2,5));//第一个数字表示截取的开始位置索引，第二个数字表示截取的结束位置的索引+1
        //目标是从s4中得到defg
        System.out.println(s4.substring(3,7));
        System.out.println(s4.substring(3));//当你只写了一个数字时，表示这是开始位置的索引，一直截取到字符串的末尾

        String s5="shamo is matongxue teacher,shamo is the best teacher";
        System.out.println(s5.replace("shamo","北河"));

        String s6="matongxue";
        //我想知道s5这个字符串是否包含s6
        System.out.println(s5.contains(s6));//这个结果是什么？，结果是一个boolean值，要么是true要么是false
        System.out.println(s5.contains("shamo"));
        s6="MatonGxUe";
        System.out.println(s6.toLowerCase());//把s6转换成小写
        System.out.println(s6.toUpperCase());//把s6转换成大写

        String s7="maTongXue";
        //我想知道s6和s7是否一样
        System.out.println(s6.equals(s7));//这个结果是什么？false
        //我不管大小写，只要这两字符串里边的字母一样就行，忽略大小写的对比
        System.out.println(s6.equalsIgnoreCase(s7));//忽略大小写的对比，结果

        String str = "小学,初中,高中,大专,本科,研究生,博士";
        str.split(",");//表示用,把str字符串进行分割，分割以后会形成7部分
        System.out.println(str.split(",")[0]);//小学是第一部分，索引对应的是0
        System.out.println(str.split(",")[1]);//小学是第一部分，索引对应的是0
        String s8="1080*1920";
        s8.split("\\*");
        System.out.println(s8.split("\\*")[0]);
        s8="sdhhfh";

        StringBuffer stringBuffer=new StringBuffer("abc");
        stringBuffer.append(1253);
        System.out.println(stringBuffer);

数组

普通数组

public class ArrayStudy {
    public static void main(String[] args) {
        //int表示这个数组里存储的数据类型
        //[]表示这是一个数组变量
        //iArray是数组变量的名称
        //new int[3] 这里的数字表示这个数组里只能存储3个元素
        int[] iArray=new int[3];
        iArray[0]=3;//变量名称后面的中括号里的数字表示索引
        iArray[1]=5;
        iArray[2]=8;
        //iArray[3]=18;//肯定会报错，超出数组大小了
        //把数组里的第一个值和第二值加起来
        int sum=iArray[0]+iArray[1];
        System.out.println(sum);

        //定义一个数组，用来存储全班学员的姓名
        String[] stuNames=new String[3];
        stuNames[0]="张三";
        stuNames[1]="李四";
        stuNames[2]="王五";
//        System.out.println(stuNames[0]);
//        System.out.println(stuNames[1]);
//        System.out.println(stuNames[2]);
        //采用循环打印所有学员的姓名,这种方式叫做遍历数组
        //for循环整体结构的快捷方式是itar
//        for (int i = 0; i < stuNames.length; i++) {
//            System.out.println(stuNames[i]);
//        }
        //要打印全班学员里姓张的同学姓名,并且计算出姓张同学的个数
        int count=0;
        for (int i = 0; i < stuNames.length; i++) {
            String stuName = stuNames[i];
            //判断学员姓名的第一个字是不是张，如果是则打印,并且给count变量加个1
//            String first = stuName.substring(0, 1);//得到学员姓名的第一个字
//            if (first.equals("张")){
//                System.out.println(stuName);
//            }
            if (stuName.startsWith("张")){
                System.out.println(stuName);
                count=count+1;//这等同于count++
            }
        }
        System.out.println(count);

        String str = "小学,初中,高中,大专,本科,研究生,博士";
        String[] split = str.split(",");
        for (int i = 0; i < split.length; i++) {
            String s = split[i];
            System.out.println(s);
        }

        double[] dArray={18,19,30,49};
        System.out.println(dArray.length);
    }
}

ArrayList

public static void main(String[] args) {

        String[] sArray=new String[3];
        System.out.println("数组大小是："+sArray.length);
        //定义一个ArrayList,对于集合来说，尖括号里规定了这个集合里可以存储的数据类型
        ArrayList<String> sList=new ArrayList<String>();
        System.out.println("集合大小是："+sList.size());//表示集合的大小，指的是集合里存储多少个数据
        sList.add("张三");//这是向集合里添加一个元素"张三"
        System.out.println(sList.size());//因为添加了一个元素，所以集合的大小变成了1
        sList.add("李四");
        sList.add("王五");
        System.out.println(sList.size());//3
        sList.remove(1);//通过索引删除1这个索引对应的元素
        System.out.println(sList.size());//2
        sList.add(0,"赵六");//插入一个元素，他的位置是0
        System.out.println(sList.size());//3

        //我要打印集合里所有的元素信息
        for(String s:sList){
            System.out.println(s);
        }
        //给集合里所有的元素都加上20210105的后缀
        for(int i=0;i<sList.size();i++){
            String s = sList.get(i);
            sList.set(i,s+"_20210105");//重新设置当前元素为新的值
        }
        for (String s : sList) {
            System.out.println(s);
        }

        //需求，存储全班学员成绩的一个集合,成绩类型暂定为int
        ArrayList<Integer> iList=new ArrayList<Integer>();
        iList.add(89);
        iList.add(89);
        iList.add(67);
        iList.add(78);
        iList.add(56);
        //得到全班最高分，及全班平均分（总分/全班人数）
        int max=0;//假设最大数是0，然后遍历集合中的每一个数字，和max进行比较，如果比max大则将他的值赋值给max
        int sum=0;
        for (Integer integer : iList) {
            if (integer>max){
                max=integer;//如果比max大则将他的值赋值给max
            }
            sum=sum+integer;
        }
        System.out.println("全班最高分是："+max);
        System.out.println("全班平均分是："+sum/iList.size());
        //全班分数超过70的有多少个
        int count=0;
        for (int i = 0; i < iList.size(); i++) {
            //如果当前分数大于70，则count自增1
            if (iList.get(i)>70){
                count++;
            }
        }
        System.out.println("全班大于70的人数是："+count+"个");

        //数据转换时会经常用到包装类
        int a=10;
        String s = String.valueOf(a);//s="10"；
        String s1="109";
        String s2="209";
        System.out.println(s1+s2);
        int i = Integer.parseInt(s1);
        int i1 = Integer.parseInt(s2);
        System.out.println(i+i1);


    }

set集合

 public static void main(String[] args) {
        //定义一个Set集合,set类型的集合对象是没有索引的
        HashSet<Double> doubleSet=new HashSet<Double>();
        doubleSet.add(99d);
        doubleSet.add(99d);//HashSet集合里的元素是不能重复的
        doubleSet.add(88d);
        doubleSet.add(78d);
        doubleSet.remove(88d);
        System.out.println(doubleSet.size());
        Object[] objects = doubleSet.toArray();//将集合转换成数组
        System.out.println(objects[1]);
        //自定义实现set转换成ArrayList
        ArrayList<Double> dList=new ArrayList<Double>();
        for (Double aDouble : doubleSet) {
            dList.add(aDouble);//把set集合的每一个元素都加到ArrayList里去
        }

        //set集合和arraylist有什么区别
        //1.set集合不能随便插入元素，ArrayList可以
        //2.set集合的元素没有顺序，ArrayList的元素有顺序
        //3.set集合里的元素是不能重复的，ArrayList里的元素是可以重复的
    }

冒泡排序

//冒泡排序
        int[] iArray={78,56,34,67,45,46,66,10};
        //相邻的两个数据进行比较，谁大谁就往后放
        for (int i = 0; i < iArray.length; i++) {//外循环
            //j=1时，{56,78,34,67,45,46,66,10}
            //j=2时，原始{56,34,78,67,45,46,66,10}
            //当i=0时，内循环执行完后数组变成了{56,34,67,45,46,66,10,78}
            //当i=1时，内循环执行完后数组变成了{34,56,45,46,66,10,67,78}
            for (int j = 0; j < iArray.length-1; j++) {//内循环
                //如果iArray[j]>iArray[j+1],那么他两交换位置
                if (iArray[j] > iArray[j + 1]) {
                    int tmp = iArray[j + 1];//先把56赋值给tmp
                    iArray[j + 1] = iArray[j];//然后把78赋值给第二个位置
                    iArray[j] = tmp;//再把56赋值给第一个位置
                }
            }
        }

HashMap

public static void main(String[] args) {
        //学员有姓名、成绩、年龄
        //name=沙陌,age=30,score=88
        //name=张三,age=29,score=78
        //定义一个HashMap对象，来表示沙陌这个学员
        //Map对象是用来存储key=value这种键值对数据的,map中的键值对数据也没有索引
        //hashmap里的key是不能重复的
        HashMap<String,String> shamoMap=new HashMap<String,String>();
        shamoMap.put("name","沙陌");
        shamoMap.put("age","30");
        shamoMap.put("score","78");
        //过了一年，沙陌的年龄增加了一岁，我要修改年龄
        shamoMap.put("age","31");//再次put一个已经存在的key,则会覆盖原有key，value
        shamoMap.replace("age","31");//这个方法表示替换age的值为31
        //沙陌毕业了，再也没有成绩了，删除掉成绩这个字段
//        shamoMap.remove("score");//表示删除score对应这一对key value
        //校长来了，说把沙陌的年龄给我打印出来
        System.out.println(shamoMap.get("age"));//这表示获取age这个key所对应的value值
        //map对象的大小，这个大小指的是键值对的总数量
        System.out.println(shamoMap.size());

        //校长说把沙陌的所有信息给我打出来
        //打印所有的value值
        Collection<String> values = shamoMap.values();//得到map里所有的value值
        for (String value : values) {
            System.out.println(value);
        }
        //校长又说了，把学员的key和value都给我打出来，这样我好区分
        //遍历所有的key value，key=value这种整体叫做Entry对象
        Set<Map.Entry<String, String>> entries = shamoMap.entrySet();//得到map里所有的键值对，一个键值对就是一个Entry对象
        for (Map.Entry<String, String> entry : entries) {
            String key=entry.getKey();//从Entry对象里得到key
            String value=entry.getValue();//从Entry对象里得到value
            System.out.println(key+"="+value);
        }
        //我只想打印每一个键值对的key值
        //遍历所有的key值
        Set<String> keySet = shamoMap.keySet();//得到map里所有的key值
        for (String s : keySet) {
            System.out.println(s);
            //既然得到了key,那么value值也很容易得到
            System.out.println(shamoMap.get(s));
        }
        //一个map对象表示一个学员，三个学员则需要三个map对象
        //如果用数组存三个map对象
        HashMap[] stus=new HashMap[3];
        //如果用ArrayList来存三个map对象？
        ArrayList<HashMap<String,String>> stuList=new ArrayList<HashMap<String, String>>();


    }

异常处理

public class ExceptionStudy {
    public static void main(String[] args){
        int[] iArray=new int[3];
        try {
            //把有可能出现异常的代码，放在try的这个大括号里边
            int i=2/0;//这行会报一个分母不能为0的异常
            iArray[3]=10;//这行会报一个数组越界的异常
        }catch (ArrayIndexOutOfBoundsException e){
            //catch相当于警察，在这里蹲点，等你犯错
            //当出现异常以后你想怎么处理就在这里写
            System.out.println("这是一个数组越界的异常，被我捕获到了");//1
        }catch (ArithmeticException e){
            System.out.println("这是一个分母不能为0的异常，被我捕获到了");//2
        }finally {//这表示不管上面执行的是try还是catch，这里都会被执行
            System.out.println("这表示不管上面执行的是try还是catch，这里都会被执行");
        }

        System.out.println("数组第四个元素赋值完成");
        try {
            iArray[3]=10;
        }catch (Exception e){//Exception类是所有异常的父类
            System.out.println("不管try代码块里出现什么样的异常，都会被我捕获到");
        }

        //throws xxxException 这是java里的抛异常，他认为我这个方法可能会出现一些异常，导致你的代码执行中断
        //当我想处理或者我有能力处理的时候，就要用try...catch代码块来处理
        try {
            Thread.sleep(3000);//线程休眠等待，参数单位是毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("这里出现异常了，记在日志里，不影响我整个代码的执行");
        }

        try {
            System.out.println("查找元素");
            System.out.println("找到元素了");
        }catch (Exception e){
            System.out.println("没找到元素");
        }

    }
}