2.JAVA语言基础

最新推荐文章于 2024-06-05 08:30:00 发布

want you tell me why

最新推荐文章于 2024-06-05 08:30:00 发布

阅读量294

点赞数

分类专栏： JAVAWeb全栈文章标签： java

本文链接：https://blog.csdn.net/weixin_42655231/article/details/108932360

版权

JAVAWeb全栈专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.基本数据类型

2.流程控制

3.字符串

4.数组

5.类和对象

6.包装类

（1）Scanner类

package cn.itcast;

import java.util.Scanner;
/*
scanner 类的功能,可以实现键盘输入数据

引用类型（不是基本类型就是引用类型）
1.导包
只有java.Lang包下的内容不需要导包，其他的都需要导包import

2.创建
类名称 对象名  = new 类名称（）;

3.使用
对象.成员方法名（）;

获取int：nextint；
获取字符串：next;

*/

public class test {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in); // 从键盘接收数据

        int number = scan.nextInt();
        String str = scan.next();//不能读取带空格
        String s = scan.nextLine();//nextline以enter为结束符

        System.out.println("input number:"+number);
        System.out.println("input string:"+str);
        System.out.println("nextline:"+s);
    }
}

12313
www baidu com
input number:12313
input string:www
nextline: baidu com

（2）匿名对象

匿名对象的说明：

package cn.itcast;

/*
匿名对象的使用
匿名对象就是只有右边的对象,没有左边的名字和赋值运算符
new 类名称（）
匿名对象只能使用唯一的一次；
什么时候使用？
如果确定有一个对象只使用唯一的一次,就可以匿名对象;
*/


public class test {
    public static void main(String[] args) {
        //匿名对象
        new person().str = "hello java";
        new person().showstr();
    }
}

（3）random

1.简单使用

package cn.itcast;

import java.util.Random;

/*
random类用来生成随机数字
*/

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt();//生成一个随机数

        for(int i=0;i<10;i++){
            //生成指定范围的数字
            int number = r.nextInt(10); //范围是 0-9  
            System.out.println("random:"+number);
        }

    }
}

（4）对象数组

person类：

package cn.itcast;

public class person {
    private String name;
    private int age;

    //无参构造
    public person() {

    }

    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

（5）对象数组：

package cn.itcast;

import java.util.Random;

/*
定义一个数组,用来存储n个对象

缺点：一旦创建，程序运行期间长度不可以发生改变
*/

public class test {
    public static void main(String[] args) {
        //创建长度为3的数组 存放person类
        person[] array = new person[3];

        person one = new person("迪丽热巴",18);
        person two = new person("古力娜扎",17);
        person three = new person("马尔扎哈",19);

        //地址值放到数组中
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        person temp = array[0];
        System.out.println(temp.getAge()+" "+temp.getName());
    }
}

（6）arraylist集合

package cn.itcast;

import java.util.ArrayList;

/*

arraylist的长度是可以随意改变的
sout:arraylist是内容
常用方法：
添加元素：add
访问元素：get
修改元素：set
删除元素：remove
计算大小：size()

*/

public class test {
    public static void main(String[] args) {
        //从JDK1.7开始,右侧的尖括号内部可以不写内容，但是<>要写
        ArrayList<String> sites = new ArrayList<>();
        System.out.println(sites);

        //add
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);

        //set
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        System.out.println(sites);
        //get
        System.out.println(sites.get(1));  // 访问第二个元素

        //remove
        sites.remove(3); // 删除第四个元素
        System.out.println(sites);

        //size
        System.out.println(sites.size());
    }
}

arraylist：
保存的类型只能是泛型，引用类型，不能是基本类型，保存的是地址值，而基本类型没有地址值
如果希望存储基本类型：必须使用基本类型对应的包装类
包装类都在java.lang下

从JDK1.5开始，支持自动装箱、自动拆箱

自动装箱：基本类型-包装类型

自动拆箱：包装类型-基本类型

基本类型对应的包装类表如下：

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer 【特殊】
long	Long
float	Float
double	Double
char	Character【特殊】

（7）string

（1）字符串创建

java.lang.string类代表字符串
Java程序中所有的字符串字面值（”abc“）都作为此类的实例实现
也就是说，所有双引号字符串，都是string类的对象（就算没有new，也是string对象）

字符串的特点：
1.字符串的内容永不可变
2.正是因为用不可变，所以可以共享使用
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

常见字符串的3+1种方式：
三种构造方法：
public String():创建一个空白字符串，不含有任何内容
public String(char[] bytes) : 根据字符数组创建
public String(byte[] bytes) ： 根据字节数组创建
直接创建：
string str = ”abc“;

package cn.itcast;


public class test {
    public static void main(String[] args) {

        String str1 = new String();
        System.out.println(str1);

        //字符数组创建
        char[] arr = {'A','B','C'};
        String str2 = new String(arr);
        System.out.println(str2);

        //字节数组

        byte[] bytearr = {97,98,99};
        String str3 = new String(bytearr);
        System.out.println(str3);
        
        //直接创建

    }
}

（2）字符串常量池：

字符串常量池：程序当中直接写上的双引号字符串都在字符串常量池中

对于基本类型来说，==进行数值的比较
对于引用类型来所，==进行地址值的比较

字符串常量池保存的是byte[]的地址

public class test {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] arr = {'a','b','c'};
        String str3 = new String(arr);

        System.out.println(str1==str2);
        System.out.println(str2==str3);
        System.out.println(str1==str3);
    }
}

true
false
false

str1和str2、str3内存分布

对于引用类型，==进行的是地址值的比较
双引号直接写的字符串在常量池当中，new的不在池当中

（3）使用方法

字符串使用方法
1.字符串的比较 （必须对象相同，而且内容相同）
2.获取字符串长度 length()
3.拼接字符串 concat()
4.获取指定索引的字符 charAt()
5.查找字符串在本字符串首次出现的位置，如果没有，返回-1 indexof(string str)

1~4：

public class test {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] arr = {'a','b','c'};
        String str3 = new String(arr);
        String str4 = null;

        //字符串的比较
        System.out.println(str1.equals(str2));//true
        System.out.println(str1.equals(str3));//true
        System.out.println("abc".equals(str2));//true
        //null此处
        System.out.println("abc".equals(str4));//false
        //System.out.println(str4.equals("abc"));//不推荐,报错，空指针异常NullpointException


        //字符串的长度
        String site = "www.runoob.com";
        int len = site.length();
        System.out.println( "菜鸟教程网址长度 : " + len );

        //字符串的拼接
        String string1 = "菜鸟教程网址：";
        System.out.println("1、" + string1 + "www.runoob.com");

        System.out.println("我的名字是 ".concat("Runoob"));

        //获取指定索引的字符
        char result = site.charAt(6);
        System.out.println(result);
    }
}

字符串的查找
1.public int indexOf(int ch)
返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

2.public int indexOf(int ch, int fromIndex)
返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

3.int indexOf(String str)
返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

4.int indexOf(String str, int fromIndex)
返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

public class test {
    public static void main(String[] args) {
        String string = "aaa456ac";

        //查找字符存在的位置

        System.out.println(string.indexOf("b")); //-1，"b"不存在
        System.out.println(string.indexOf("a",3));//返回结果：6  ，从第四个字符位置开始往后继续查找，包含当前位置

        //（与之前的差别：上面的参数是 String 类型，下面的参数是 int 类型）参考数据：a-97,b-98,c-99
        // 从头开始查找是否存在指定的字符
        System.out.println(string.indexOf(99));//indexOf(int ch)；返回结果：7
        System.out.println(string.indexOf('c'));//indexOf(int ch)；返回结果：7

        System.out.println(string.indexOf(97,3));//indexOf(int ch, int fromIndex); 返回结果：6
        System.out.println(string.indexOf('a',3));//indexOf(int ch, int fromIndex); 返回结果：6

        //查找字符串存在的位置
        String Str = new String("菜鸟教程:www.runoob.com");
        String SubStr1 = new String("runoob");
        String SubStr2 = new String("com");

        System.out.print("子字符串 SubStr1 第一次出现的位置:" );
        System.out.println( Str.indexOf( SubStr1 ));
        System.out.print("从第十五个位置开始搜索子字符串 SubStr1 第一次出现的位置 :" );
        System.out.println( Str.indexOf( SubStr1, 15 ));
        System.out.print("子字符串 SubStr2 第一次出现的位置 :" );
        System.out.println(Str.indexOf( SubStr2 ));
    }
}

字符串的截取：

/*
字符串的截取
substring(int index):截取参数位置直到最后结束，返回新字符串
substring(int begin,int end):取从begin到end，中间的字符串（左闭右开）
*/

public class test {
    public static void main(String[] args) {
        String str = "hello world";
        System.out.println(str.substring(1));
        System.out.println(str.substring(4,8));

        //下边在字符串常量池开辟了两个字符串 hello java
        //s1先指向 hello 再指向java
        //s1保存的地址先后发生了改变

        String s1 = "hello";
        System.out.println(s1);
        s1 = "java";
        System.out.println(s1);
    }
}

字符串的替换：

字符串转换的相应的方法：
1.字符串转成字符数组 toCharArray();
2.字符串转成字节数组 getBytes();
3.将所有出现的老的字符串转变成新的字符串，返回替换后的新的字符串
replace(charSequence oldstring,charSequence newSrtring)
tip：charSequence指可以接收字符串类型

public class test {
    public static void main(String[] args) {
        //1.转成字符数组
        String str = "abc";
        char[] arr = str.toCharArray();
        System.out.println(arr);

        //2.转成字节数组
        byte[] bytes =  str.getBytes();
        for(int i=0;i<bytes.length;i++){
            System.out.println(bytes[i]);
        }

        //3.字符串替换
        String Str = new String("how do you do");

        System.out.println(Str.replace('o', '*'));
        System.out.println(Str);

    }
}

字符串的分隔：

public class test {
    public static void main(String[] args) {
        String str = "aaa,bbb,ccc";
        String[] arr = str.split(",");
        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

注意情况：

split的参数是一个正则表达式
如果按照“.”,必须写“\\.”
因为"."在正则表达式中有特殊含义

public class test {
    public static void main(String[] args) {
        String str = "aaa.bbb.ccc";
        String[] arr = str.split("\\.");//切分失败
        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

（8）Array

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arr = {10,30,20};

        //转换成字符串
        String instr = Arrays.toString(arr);
        System.out.println(instr);

        //排序
        int[] array = {2,1,4,3};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

（9）Math

math使用：
1.abs 绝对值
2.ceil 向上取整
3.floor 向下取整
4.long round 四舍五入

7.数字处理类

8.静态内存

静态代码块的格式

public class 名称{
     static{
        //内容
     }
}

//特点：
当第一次用到本类的时候，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行

静态代码块的典型用途：
用来一次性的对静态成员变量进行赋值