Java基础每日Study

Piink

已于 2022-04-04 17:04:35 修改

阅读量739

点赞数

分类专栏： Java 文章标签： java

于 2021-12-29 12:26:40 首次发布

本文链接：https://blog.csdn.net/Piink/article/details/122212892

版权

Java 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

快捷输入

pvsm              public static void main(String[] args)
sout              System.out.println();
5.fori            for (int i = 0; i < 5; i++)
array.fori        for (int i = 0; i < array.length; i++)

Scanner

1 导包

import java.util.Scanner;
导包的动作必须出现在类定义的上边

2 创建对象

Scanner sc = new Scanner(System.in);
上面这个格式里面，只有sc是变量名，可以变，其它的都不允许变

3 接收数据

int i = sc.nextInt();//数字
String str=sc.next()；//字符串
上面这个格式里面，只有i是变量名，可以变，其它的都不允许变

在这里插入图片描述

Random
作用：用于产生一个随机数

1 导包

import java.util.Random;
导包的动作必须出现在类定义的上面

2 创建对象

Random r = new Random(）;
上面这个格式里面，r是变量名，可以变，其它的都不允许变

3 获取随机数

int number = r.nextInt(10);//获取数据的范围：[0，10）包括0，不包括10
上面这个格式里面，number是变量名，可以变，其它的都不允许变

数组定义

   int[] a =new int[10];//动态初始化
   String[] b=new String[1010];

面向过程与面向对象

面向过程（强调步骤）：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节

面向对象（强调对象）：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事

面向对象思想是一种更符合我们思考习惯的思想，将复杂事情简单化，从执行者转变为指挥者，面向对象的语言，包含三大特征：封装、继承和多态
在这里插入图片描述

package face;

import java.util.Arrays;

public class demo {
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};

        //打印出这样格式的数组[1， 2， 3， 4， 5]
        //使用面向过程，每一步都要亲历亲为
        System.out.println("面向过程");
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if(i==0)
                System.out.print(array[i]);
            else
                System.out.print(", "+array[i]);
        }
        System.out.println("]");

       //使用面向对象
        //找一个JDK给我们提供好的Arrays类
        //其中有一个toString方法，直接就能把数组编程想要的格式字符串
        System.out.println("面向对象");
        System.out.println(Arrays.toString(array));//面向对象直接可以实现
    }
}

在这里插入图片描述

类与成员变量

public class Student {
    String name;
    int age;
    public void eat() {
         System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void study() {
        System.out.println("学习");
    }
}

public class demo {
    public static void main(String[] args) {
        Student stu =new Student();//定义一个stu类
        System.out.println(stu.name);
        System.out.println(stu.age);
        stu.name="aaa";
        stu.age=18;//name,age都是成员变量
        System.out.println(stu.name);
        System.out.println(stu.age);
    }
}

在这里插入图片描述

ArrayList创建与使用

import java.util.ArrayList;

public class demo01 {
    public static void  main(String[] args) {
     ArrayList<String> list=new ArrayList<>();//创建
        System.out.println(list);
        list.add("abc");
        System.out.println(list);
        list.add("abcc");
        list.add("abccc");
        list.add("abccccc");
        System.out.println(list);
    }
}

在这里插入图片描述

package fass;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
/*
ArrayList当中的常用方法
public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致，返回值代表是否添加成功
public E get(int index):从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index):删除元素，参数是索引编号，返回值就是被删掉的元素
public int size():获取集合的尺寸长度，返回值是集合中包含的元素个数
 */
public class demo01 {
    public static void  main(String[] args) {
     ArrayList<String> list=new ArrayList<>();
        System.out.println(list);
        //向集合中添加元素：add
        //对于ArrayList添加是一定成功的，所以返回值可用可不用
        //但是对于其它集合来说，add添加动作不一定成功
        boolean success =list.add("张三");
        System.out.println(list);
        System.out.println("添加的动作是否成功："+success);
        list.add("李四");
        list.add("王五");

        //获取查询
        String name=list.get(2);
        System.out.println("2号："+name);

        //删除
        String name1=list.remove(1);
        System.out.println("删除："+name1);
        System.out.println(list);
        //计算ArrayList的长度，也是元素个数
        int l=list.size();
        System.out.println("长度："+l);
        System.out.println("-----------");
        //遍历ArrayList
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

统计字符串字符出现的次数

ToCharArray( )的用法：将字符串对象中的字符转换为一个字符数组。

package pac;

import java.util.Scanner;

public class clas {
    public static void main(String[] args) {
        String strin=new String();
        System.out.println("输入一个字符串:");
        Scanner sc=new Scanner(System.in);
        
        String str=sc.next();//从键盘输入一个字符串，但这个字符串不是数组
        
        char[] str1=str.toCharArray();//转换为数组才可以用下面的if语句
        
        int ans=0,ans1=0,ans2=0,ans3=0;
        for (int i = 0; i < str.length(); i++) {
            if (str1[i]>='A'&&str1[i]<='Z')
                ans++;
            else if (str1[i]>='a'&&str1[i]<='z')
                ans1++;
            else if (str1[i]>='0'&&str1[i]<='9')
                ans2++;
            else
                ans3++;
        }
        System.out.println("大写："+ans+"小写："+ans1+"数字："+ans2+"其它："+ans3);
    }
}

Sort用法：对数字或字符串排序

 String str="sbhjbjhbdefbjfvbfnhjbf";//字符串
       char[] str1=str.toCharArray();//转换为字符数组
       Arrays.sort(str1);//对字符数组进行排序

Date计算日期类问题

public static void main(String[] args) throws ParseException {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入出生日期：");
        String birthday=sc.next();//获取字符串
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-dd");//注明输入的日期的格式
        Date bir=sdf.parse(birthday);//使用DateFormat的parse把字符串的出生日期解析为Date格式
        long birtime=bir.getTime();//转换为毫秒值

        long todaytime=new Date().getTime();//获取当前时间，转换为毫秒值
       // System.out.println(todaytime);
        long time=todaytime-birtime;
        System.out.println(time/1000/60/60/24);//计算天数
    }

public class Test01 {
    public static void main(String[] args) throws ParseException {
        //空参构造方法
        Date d=new Date();
        System.out.println(d.toLocaleString());//根据本地格式转换日期对象
        Date d1=new Date(3000L);
        System.out.println(d1.toLocaleString());
        
        //创建日期格式化对象
        //按照指定格式格式化日期对象
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
         String format=sdf.format(d);
         System.out.println(format);
         //根据指定格式解析字符串
         String str="2022-02-02 02:02:02";//格式需与SimpleDateFormat一样
         Date parse=sdf.parse(str);
         System.out.println(parse);
    }
}

Calendar类的常用成员方法

 //public int get(int field);返回给定日历字段的值
    //public void set(int field,int value);将给定的日历字段设置为给定值
    //public abstract void add(int field,int amount);根据日历的规则，为给定的日历添加或减去指定的时间量
    //public Date getTime();返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)
    public static void kkk(){
        //使用getInstance方法获取Calendar对象
        Calendar c= Calendar.getInstance();
        c.set(Calendar.YEAR,2022);//自定义设置
        c.set(Calendar.MONTH,4);
        c.set(Calendar.DATE,1);
        c.add(Calendar.YEAR,2);//将年份+2
        c.add(Calendar.YEAR,-3);//将年份-3
        int year=c.get(Calendar.YEAR);//获取年
        System.out.println(year);
        int month=c.get(Calendar.MONTH);//获取月
        System.out.println(month);//西方0-11月，东方1-12月
        //int date=c.get(Calendar.DATE);//月中的某一天 or 日
        int date=c.get(Calendar.DAY_OF_MONTH);//月中的某一天
        System.out.println(date);
        int hour=c.get(Calendar.HOUR);//获取时
        System.out.println(hour);
        int minute=c.get(Calendar.MINUTE);//获取分
        System.out.println(minute);
        int second=c.get(Calendar.SECOND);//获取秒
        System.out.println(second);
    }
    public static void main(String[] args) throws ParseException {
        //使用getInstance方法获取Calendar对象
        Calendar c= Calendar.getInstance();
        kkk();
    }

System类

1.currentTimeMillis()方法

作用：获取当前系统毫秒值时间

2.arraycopy()方法

作用：复制数组

StringBuilder类

1.构造方法

StringBuilder(); 创建一个空的字符串缓冲区对象

StringBuilder(String s); 根据传入的内容创建一个空的字符串缓冲区对象

2.成员方法

StringBuilder append(Object obj); 添加内容

StringBuilder reverse(); 反转内容

String toString(); 将缓冲区转为字符串

定义和使用含有泛型的类

//写为E表示不卡类型（自我理解，有错请指出）
public class General<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

public static void main(String[] args){

      //General g=new General();
      //g.setName("只能是字符串");
      //Object obj = g.getName();
        //类型可以在下面自己定义，E不卡类型
        General<Integer> g1 =new General<>();
        g1.setName(1);
        Integer name=g1.getName();
        System.out.println(name);

        General<String> g2 =new General<>();
        g2.setName("小明");
        String name1=g2.getName();
        System.out.println(name1);

    }

泛型的上限限定：？extends E  
代表使用的泛型只能是E类型的子类/本身
public static void getElement1(Collection<? extends Number>coll){}

泛型的下线限定：？super E 
代表使用的泛型只能是E类型的父类/本身
public static void getElement2(Collection<? super Number>coll){}