本文讲述了Java教程——java学习基础！具有很好的参考价值，希望对大家有所帮助。一起跟随六星小编过来看看吧，具体如下:

一个简单的Java入门程序

首先安装JDK,然后设置环境变量，这边就不介绍Java环境的安装了。以下将使用

JDK18和IntelliJ Idea来进行Java学习。

看一个Java HelloWorld程序，创建HelloWorld.java(文件名要和class类名一致)，输入内容：

public class HelloWorld {

    public static void main(String[] args) {

        // 控制台输出

        System.out.println("Hello world!");

    }

}

首先需要定义一个public类HelloWorld，类中的静态方法main是一个主入口函数，当我们点击执行时候，就是从这个main函数为入口进行执行的。Javascript中是通过console.log来输出信息到控制台的，Java中则是使用System.out.println输出信息。

执行HelloWorld.java：可以通过在IDE中点击Run操作进行执行，也可以通过命令行执行：

打开cmd命令行工具，输入javac HelloWorld.java进行编译得到一个新的文件HelloWorld.class,然后输入java HelloWorld即可执行这个新生成的class字节码文件,最终输出Hello world!.对于新版的Java,也可以直接执行Java源文件java HelloWorld.java。

数据类型

Java中基本数据类型有以下几种：

整数类型：byte，short，int，long

浮点数类型：float，double

字符类型：char

布尔类型：boolean

Java中的字符串String和数组都是引用类型，后面介绍的所有class和interface类型也都是引用类型。

其中引用类型可以赋值为null表示空，基本类型不能赋值为null。

各基本数据类型占用的字节数分别为：

byte: 1字节

short：2字节

int：4字节

long：8字节

float: 4字节

double：8字节

char：2字节

声明整型变量:

int a = 1;

int b = a + 2;

b += 3;

short d = 6;

int t = d + a; //d自动转型为int

short i = (short) (i + 1);//将int强制转型为short

long e = 1234567890;

声明浮点型变量:

float a = 1.0f;

float b = 2.5f;

double c = 2.2;

b = (float) (c + 1);//3.2

int d = 3;   

b = d; //3.0   

b = 2.3f;        

d = (int) b; //2

声明字符类型变量:   

使用char来声明单字符变量               

char a = 'a';

char b = 'b';

int c = 'a'; //值为a的Unicodde编码97

int t = 1;

char k = '1';

t == k //false

声明字符串类型变量:   

String a = "a";

String b = "ab";

String c = a + b; //aab

int d = 12;

String e = a + d; //a12 先将其他数据类型自动转为字符串

String k = null; //空值 表示不存在

String t = ""; //空字符串

多行字符串:

String s = "a \n"

         + "b \n"

         + "c";

也可以使用"""..."""表示多行字符串:

  String s = """ 

           a

           b

           c

           """;

字符串String是个引用类型,是不可变的,如果将字符串a重新赋值,其实变得是字符串a的指向,即创建出新的字符串,然后将a指向该新建的字符串。

二个字符串判断相等通常需要使用equals方法来判断比较，这比直接使用==准确：

String s1 = "test";

String s2 = "test";

String s3 = "TEST".toLowerCase();

System.out.println(s1 == s2); //true

System.out.println(s1.equals(s2)); //true

System.out.println(s1 == s3); //false

System.out.println(s1.equals(s3)); //true

//可以使用equalsIgnoreCase()方法来忽略大小写进行比较

String s4 = "TEST";

s1.equalsIgnoreCase(s4); //true

常用字符串方法：

String test = "testba";

String test2 = "  testba   ";

String test3 = "";

String test4 = "  ";

String test5 = "a,b,c,d,e,f";

//判断是否包含某子串

test.contains("ba"); //true

//查找子串位置

test.indexOf("st"); //2

test.lastIndexOf("st"); //2

test.lastIndexOf("t"); //3

//判断是否以某字符串开始

test.startsWith("te"); //true

//判断是否以某字符串结束

test.endsWith("ba"); //true

//提取子串

test.substring(1); //estba

test.substring(1,3); //es

//去除首尾空白字符

test2.trim(); //testba

test2.strip(); //testba

test2.stripLeading(); //"testba   "

test2.stripTrailing(); //"  testba"

//判断空字符串

test3.isEmpty(); //true

test4.isEmpty(); //false

//判断是否只包含空白字符

test3.isBlank(); //true

test4.isBlank(); //true

//替换子串

test.replace("ba", "me"); //testme

test.replaceAll("t", "me"); //meesmeba

//分割字符串

String[] arr = test5.split(","); //[a, b, c, d, e, f]

//拼接字符串

String test6 = String.join("--", arr); //a--b--c--d--e--f

//将内容转为字符串

String.valueOf(123); //"123"

String.valueOf(45.67); //"45.67"

String.valueOf(true); //"true"

String.valueOf(new String("test")); //"test"

//将字符串转换为char[]

char[] arr2 = test.toCharArray(); //[t, e, s, t, b, a]

String test7 = new String(arr2); //testba

//字符编码

//按UTF-8编码

byte[] b1 = test.getBytes("UTF-8"); //[116, 101, 115, 116, 98, 97]

//按GBK编码

byte[] b2 = test.getBytes("GBK"); //[116, 101, 115, 116, 98, 97]

String test8 = new String(b1, "UTF-8"); //testba 按UTF-8转换

String test9 = new String(b2, "GBK"); //testba 按GBK转换

//将字符串类型转为整型

int test10 = Integer.parseInt("123"); //123 默认按照10进制转换

int test11 = Integer.parseInt("ff", 16); //255 按16进制转换

//将字符串类型转为boolean类型

boolean test12 = Boolean.parseBoolean("true"); // true

boolean test13 = Boolean.parseBoolean("FALSE"); // false

boolean test14 = Boolean.parseBoolean("0"); // false

boolean test15 = Boolean.parseBoolean("1"); // false

boolean test16 = Boolean.parseBoolean(""); // false

boolean test17 = Boolean.parseBoolean("123"); // false

boolean test18 = Boolean.parseBoolean("false"); // false

boolean test19 = Boolean.parseBoolean("TRUE"); //true

boolean test20 = Boolean.parseBoolean("TRue"); //true

//转为大写

String test21 = test.toUpperCase(); //TESTBA

//转为小写

test21.toLowerCase(); //testbas

//使用matches方法进行规则匹配

String test22 = "12345";

String test23 = "13345";

//\d+表示匹配1到多个数字，\\d+前面的第一个\表示转义，不加会出错

String regex = "12\\d+";

test22.matches(regex); //true

test23.matches(regex); //false

//在replaceAll方法中使用正则替换

String test24 = "test123ha567";

test24.replaceAll("\\d+", "me"); //testmehame 

上面使用了String.valueOf方法将传入的内容转为字符串，对于int整型也有类似的方法Integer.valueOf，该方法可以将传入的内容转为int型：

Integer.valueOf("1234"); //1234

Integer.valueOf("1234.2"); //error传入的内容得能转成合法的int型

//也可以通过Integer.parseInt方法来实现

Integer.parseInt("1234"); //1234

使用StringBuilder进行高效字符串拼接操作

Java中可以通过+拼接字符串，且在每次重新赋值的时候都会创建一个新的字符串对象，这很浪费内存，也影响执行效率：

String s = "test";

s = s + " test2";

s = s + " test3"; //test test2 test3

为了提高效率，可以使用Java提供的StringBuilder类，使得新增字符时不会创建新的对象：

StringBuilder sb = new StringBuilder(1024);

sb.append('a');

sb.append('b');

sb.append('c');

sb.append('d').append('e').append('f').append('g');

sb.insert(0, "test "); //在位置0插入字符串

String s = sb.toString(); //test abcdefg

sb.delete(sb.length() - 3, sb.length()); //删除最后3个字符

String s2 = sb.toString(); //test abcd

使用StringJoiner方法实现用分隔符拼接数组：

 String[] names = {"ab", "cd", "ef"};

 StringJoiner sj = new StringJoiner(",");

 for (String name : names) {

     sj.add(name);

 }

 System.out.println(sj.toString()); //ab,cd,ef

 //给StringJoiner指定“开头”和“结尾”

 StringJoiner sj2 = new StringJoiner(",","begin "," end");

 for (String name : names) {

     sj2.add(name);

 }

 System.out.println(sj2.toString()); //begin ab,cd,ef end

String中提供了一个简便的静态方法，用于实现用分隔符拼接数组，该方法内部是通过上面说的StringJoiner实现的，当不需要指定“开头”和“结尾”时，使用这个方法更方便：

 String[] names = {"ab", "cd", "ef"};

 String s = String.join(",", names); //ab,cd,ef

声明布尔型变量:

boolean a = true;

boolean b = false;

跟Javascript中boolean类型可以跟其它类型进行+操作不同,Java中的boolean不能执行下面操作:

boolean a = true;

boolean b = false;

a+b //error

int c = 1;

a+c //error

int t = c ? 3 : 7; //error c为int型不能强制转化为boolean

int k = a ? 3 : 7; //3

对于Javascript来说:

var a = true;

var b = false;

a+b //1

var c = 1;

a+c //2

var t = c ? 3 : 7;//3

声明数组类型:

int[] arr = new int[3]; //数组长度3且是整型数组

arr.length //3

arr[0] = 1;

arr[1] = 'a'; //97

arr[2] = "12"; //error

arr[2] = Integer.parseInt("12"); //12

arr[3] = 5; //出界error Index 3 out of bounds for length 3

String[] arr2 = new String[2];

arr2[0] = "test";

上述Integer.parseInt方法可以将字符串转为整型使用,前提是字符串中是合法的数字,如果是比如"12test"这种是转换不了的,会报错。

设置数组默认值:

int[] arr = new int[]{1,5,9,20};

arr.length //4

int[] arr2 = {1,5,9,20};//也可以这样简写

Arrays.toString(arr2) //打印数组 [1, 5, 9, 20]

数组是个引用类型,重新赋值也只是改变了变量指向:  

int[] arr = new int[]{1,5,9,20};

arr  = new int[]{2,6,1};

遍历数组:

int[] arr = new int[]{1,5,9,20};

for (int i=0; i<arr.length; i++) {

   System.out.println(arr[i]);

}

 for (int item : arr) {

    System.out.println(item);

 }

多维数组

 //3x4二维数组

 int[][] arr = {

            { 1, 2, 3, 4 },

            { 5, 6, 7, 8 },

            { 9, 10, 11, 12 }

  };

  arr[2][3] //12

  arr[1] //{ 5, 6, 7, 8 }

  

  //遍历二维数组

  for (int[] row : arr) {

    for (int item : row) {

        System.out.println(item);

    }

  }

  //打印出多维数组

  Arrays.deepToString(arr)//[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

                            

                                                        包装类型                       

从上面可知Java基础数据类型包括：byte，short，int，long，boolean，float，double，char这些，这些类型都有其对应的包装类型，可以将这些基本数据类型转为对应的引用类型：

byte ：java.lang.Integer

short : java.lang.Short

int : java.lang.Integer

long : java.lang.Long

boolean : java.lang.Boolean

float: java.lang.Float

double: java.lang.Double

char : java.lang.Character

int test = 123;

//返回包装类型，即装箱，也可以通过new Integer(i)但不推荐

Integer test2 = Integer.valueOf(test);

//返回原始值,即拆箱

int test3 = test2.intValue();

 Java编译器可以自动进行基本类型和包装类型之间的转换：

Integer test = 123; //编译器自动使用Integer.valueOf

int test2 = test; //编译器自动使用Integer.intValue

拆箱时可能会发生NullPointerException错误：

Integer test = null;

int test2 = test; //出错

包装类型间通过equals方法进行比较，==比较不太准确：

Integer test = 123;

Integer test2 = 123;

test.equals(test2); //true

装箱和拆箱会影响执行效率，拆箱时可能会发生NullPointerException错误，所以平时使用时需要慎重。

更多相关技术内容咨询欢迎前往并持续关注六星社区了解详情。

想高效系统的学习Java编程语言，推荐大家关注一个微信公众号：Java圈子。每天分享行业资讯、技术干货供大家阅读，关注即可免费领取整套Java入门到进阶的学习资料以及教程，感兴趣的小伙伴赶紧行动起来吧。