【Java】学习笔记1——从小小白到小白（基础知识篇）
写在前面
之前一直都是使用C、C++和Python，对Java完全没有涉及。作为一个即将大二的CS专业学生，不掌握这门如此重要和强大的网络编程语言实在有点说不过去（其实是为小学期做准备）。
废话不多说，这就开干！
创建“Java学习笔记”这个系列的博文的目的有两个：
一是记录自己学习Java的历程，待我基本掌握了Java，再回过头来看这段学习历程，肯定有不一样的感觉和收获。
二是把这些博文当做一个可编辑的学习笔记使用，为的是今后需要之时能够快速便捷地翻阅查找并及时补充新知识。
————————————————————————————————————————————————————
2020.6.21 【Day1】
Java程序的运行过程：
写好的程序源代码，经过编译器处理后转化为中间语言——Java字节码，之后Java虚拟机对字节码进行处理生成机器码，从而在计算机上运行。
Java的版本：
1.Java SE：即Java的标准版，这也是我将要学习的版本。
2.Java EE：用于开发企业级分布式网络程序。
3.Java ME：用于做嵌入式系统开发。
开发环境的搭建步骤：
1.下载安装JDK环境。
2.在Win10系统中配置环境变量。
3.下载安装Eclipse（IDEA也不错）。
4.下载安装中文语言包。
5.配置Eclipse开发环境。
大功告成：
下面就要开始写第一个Java程序了
输出Hello Java:
public class HelloJava
{
private static String sentance = "I will company with you during the whole summer vacation!";
public static void main(String[] args)
{
System.out.println("\nHello，Java!\n"+sentance);
}
}
程序输出：
Hello，Java!
I will company with you during the whole summer vacation!
虽然还不是很懂每条语句的具体作用，但能够输出Hello Java还是很开心的。
PS：看多了C风格的代码，一下子没有#include < iostream>和using namespace std;，还真有点不适应。
————————————————————————————————————————————————————
2020.6.22 【Day2】
先理解一下昨天写的第一个程序：
public表示的这个程序的访问权限，表示任何的场合可以被引用。这样Java虚拟机就可以找到main()方法，从而来运行Java程序。private的作用则与之相反，即访问权限私有，这一点和C++相同。
程序中先定义了一个public的HelloJava类，之后在这个类里面定义了一个private static类型的字符串santance，static表明方法是静态的，其不依赖类的对象，是类的成员，在类加载的时候main()方法也随着加载到内存中去。
之后写main方法：
public static void main(String[] args)
main方法是Java程序的入口地址，Java虚拟机运行程序的时候首先找的就是一个程序的main方法。这和C当中的main函数作用相同，C程序也是从main函数开始执行的，只不过main方法是写在类的内部。
String[ ] args是main方法的参数，其本质是一个字符串数组，用于接收来自程序执行时传进来的参数。和C语言main函数的参数作用等价。
int main(int argc,char *argv[])
再写输出语句：
System.out.println("\nHello，Java!\n"+sentance);
其中system是Java自带的类，其内部有个静态数据成员out，并且这个成员out还是java.io.PrintStream类（也是Java自带的类）的引用，而println()就是java.io.PrintStream类里的一个方法，它的作用是向控制台输出信息。后面括号内的加号+则起到字符串连接的作用。
经过查阅资料后，了解到Java输出除了println()这个方法之外，还有print()方法和printf()方法。三者的用途如下：
1.println()方法在输出信息后会自动换行，其将它的参数显示在命令窗口，并在结尾加上换行符，将输出光标定位在下一行的开始。但是由于println()在输出之后自动换行，故这个函数不能指定输出格式。
2.print()方法在输出信息之后不会换行，其将它的参数显示在命令窗口，并将输出光标定位在所显示的最后一个字符之后。其与println()方法最大的区别在于print()方法可以格式化输出，这是println()所不能比拟的。
3.printf()方法明显是继承了C语言里面的输出函数printf()，其也是格式化输出函数，一般用于向标准输出设备按规定格式输出信息。调用格式如下：
printf("<格式字符串>",<参量表>);
————————————————————————————————————————————————————
2020.6.23 【Day3】
Java和C++都是面向对象的编程语言，所以Java的基本组成单元也是类，而Java的类体里面又包含了属性与方法两个部分，其中属性类似于C++类中的成员变量，而方法类似于C++类中的成员函数。若干个类则可以组成一个包（package），有关包的知识过段时间会学习。
对于一个项目来说，在众多的类当中有且只有一个类含有main()方法，这个类便是主类，主类的main()方法不可缺少。
顺带一提，发现了几个Java和C++的区别：
1.boolean：对于布尔类型的变量，C++中用bool关键字声明，而在Java中则用boolean关键字进行声明，关键字不同，定义方法相同。
2.final：这个关键字用于声明常量。如果想声明一个π，可以这么写：
public static final double PI = 3.1415926;
3.break与标签：当写一个循环的时候，我们可以在循环体前面写一个标签，此时如果在循环当中的break语句后面加上标签，便可以随意打破这个标签所指向的循环。比如下面这段代码，实际上打破的是外层的 i 循环：
Loop: for(int i=0;i<10;i++)
{
for(int j=0;j<5;j++)
{
if(j==3)
{
break Loop;
}
}
}
————————————————————————————————————————————————————
2020.6.24 【Day4】
今天学习一些Java中有关字符串的基本操作。
字符串的连接：
public class Link1
{
public static void main(String args[])
{
String s1=new String("I");
String s2=new String("like");
String s3=new String("Java.");
String s=s1+" "+s2+" "+s3;
System.out.println(s);
}
}
程序输出：
I like Java.
Java将字符串作为对象来处理。从这个程序可以看出，在构造字符串时候使用了new关键字，这也是常用的对已知字符串的构造方法。其中起到连接作用的是加号“+”。但是要注意的是Java中一句相连的字符串不能分开在两行写，如果必须要换行写，则应该在第一行字符串末尾加上连接符“+”，用来连接上下两行，否则会报错。
当然，连接符“+”不仅仅能连接字符串，也能够连接其他类型的数据：
public class Link2
{
public static void main(String args[])
{
int time1 = 2;
double time2 = 1.5;
System.out.println("我每天花费"+time1+"小时学习数据结构，"+time2+"小时学习Java。");
}
}
程序输出：
我每天花费2小时学习数据结构，1.5小时学习Java。
获取字符串长度：
String类当中的length()方法用于求字符串长度：
public class Length
{
public static void main(String args[])
{
String s="I have lost 10 pounds (in my dream).";
int size=s.length();
System.out.println(size);
}
}
程序输出：
36
字符串查找：
String类当中有两种查找方法：indexOf(String s)和lastIndexOf(String s)，前者返回的是搜索的字符串首次出现的位置，后者返回的是搜索的字符串最后出现的位置。如果检索到相应字符，则返回该字符的下标；如果没有检索到相应字符，则两种方法均返回-1。
public class index
{
public static void main(String args[])
{
String s="I have lost 100 pounds (in my dream).";
int location1=s.indexOf("0");
int location2=s.lastIndexOf("0");
int location3=s.indexOf("@");
System.out.println(location1);
System.out.println(location2);
System.out.println(location3);
}
}
程序输出：
13
14
-1
获取指定索引位置的字符：
String类中的charAt()方法用于返回指定索引处的字符。
public class Ref
{
public static void main(String args[])
{
String s="I have lost 10 pounds (in my dream).";
char c=s.charAt(10);
System.out.println(c);
}
}
程序输出：
t
获取子串：
String类的substring()方法可以利用下标对字符串进行截取。其有两种重载方式：第一种方法内只有一个参数，该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串；第二种方法内有两个参数，该方法返回的是从字符串某一索引位置开始至另一个索引位置结束的子串。
public class Blak
{
public static void main(String args[])
{
String s="I have lost 10 pounds (in my dream).";
String s1=s.substring(7);
String s2=s.substring(15,20);
System.out.println(s1);
System.out.println(s2);
}
}
程序输出：
lost 10 pounds (in my dream).
pound
去除前后空格：
String类的trim()方法用于返回字符串的副本，即去除前导空格和尾部空格。
public class trim
{
public static void main(String args[])
{
String s=" I have lost 10 pounds (in my dream). ";
System.out.println(s);
System.out.println(s.trim());
}
}
程序输出：
I have lost 10 pounds (in my dream).
I have lost 10 pounds (in my dream).
字符串替换：
String类的replace()方法可以实现将指定的字符或字符串换成新的字符或字符串。
public class Newstr
{
public static void main(String args[])
{
String s1="I have lost 10 pounds (in my dream).";
String s2=s1.replace("o","O");
System.out.println(s2);
}
}
程序输出：
I have lOst 10 pOunds (in my dream).
判断字符串的开始和结尾：
String类中的startsWith()方法和endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，其返回值均为boolean类型。
public class StartOrEnd
{
public static void main(String args[])
{
String s="I have lost 10 pounds (in my dream).";
boolean x=s.startsWith("I");
boolean y=s.endsWith("。");
System.out.println(x);
System.out.println(y);
}
}
程序输出：
true
false
判断字符串是否相等：
判断字符串相等是不可以使用“==”的，因为其比较的是地址是否相同，即使两个字符串看起来完全一样，但它们的地址却是不同的。
String类中的equals()方法和equalsIgnoreCase()方法用于比较两个字符串是否相等。前者为普通比较，而后者在比较时会忽略大小写的差异。
public class Opinion
{
public static void main(String args[])
{
String s1="I have lost 10 pounds (in my dream).";
String s2="i Have Lost 10 Pounds (In My Dream).";
boolean x=s1.equals(s2);
boolean y=s1.equalsIgnoreCase(s2);
System.out.println(x);
System.out.println(y);
}
}
程序输出：
false
true
字母大小写转换：
String类中的toLowerCase()方法和toUpperCase()方法分别可以将大写字母转换为小写字母、小写字母转换为大写字母。
public class UpAndLower
{
public static void main(String args[])
{
String s="I Have Lost 10 Pounds (In My Dream).";
String s1=s.toLowerCase();
String s2=s.toUpperCase();
System.out.println(s1);
System.out.println(s2);
}
}
程序输出：
i have lost 10 pounds (in my dream).
I HAVE LOST 10 POUNDS (IN MY DREAM).
————————————————————————————————————————————————————
2020.6.25 【Day5】
端午假期，外出游玩，未学习。
————————————————————————————————————————————————————
2020.6.26 【Day6】
继续Java中关于字符串的知识。
String类的format()方法用于创建格式化字符串。
例如，输出当前日期时间的程序：
import java.util.Date;
public class DateAndTime
{
public static void main(String [] args)
{
Date date=new Date();
String time1=String.format("%tc",date);
String time2=String.format("%tF",date);
System.out.println("输出为全部时间信息格式："+time1);
System.out.println("输出为年-月-日格式："+time2);
}
}
程序输出：
输出为全部时间信息格式：周五 6月 26 21:48:55 GMT+08:00 2020
输出为年-月-日格式：2020-06-26
可以看出，对于同一个date变量，其可以用不同的格式化转换符（%tc、%tF）进行修饰，从而按照相应的格式输出不同的结果。
特殊的格式化转换符有很多种，随便找一本Java参考书或者上网搜一搜即可，在此就不全部列出了，主要是通过这个实例了解Java中的格式化字符串的功能。
除了像日期这样的复杂的格式化之外，常规类型的格式化也有着广泛应用。其中大部分格式化符号也适用于C风格的代码。
%b ：布尔类型格式化
%h ：散列码格式化
%s ：字符串格式化
%c ：字符格式化
%d ：十进制整数格式化
%o ：八进制整数格式化
%x ：十六进制整数格式化
%e ：科学计数法格式化
%% ：输出%
最后再来看看J2SE 5.0新增的字符串生成器功能。
字符串生成器适用于需要频繁附加字符串的程序，其使用方法类似于C++中vector、list之类的动态容器。字符串生成器含有append()、insert()、delete()三个方法，分别用于向字符串生成器后追加内容、向指定位置插入内容、移除字符串生成器中的相应内容。每种方法均有多种重载方式，适用于不同的情况，具体使用方法还请参见java.lang.StringBuilder。
例如，利用字符串生成器中的toString()方法向字符串后追加1~10这10个数字的程序如下：
public class Eval
{
public static void main(String[] args)
{
StringBuilder builder = new StringBuilder("a");
for (int i=1;i<=10;i++)
{
builder.append(i);
}
System.out.println(builder.toString());
}
}
程序输出：
a12345678910
————————————————————————————————————————————————————
2020.6.27 【Day7】
今天学习Java中有关数组的知识。
一维数组：
在声明一个数组之后，不能立即访问其元素，还需要给数组分配内存空间。分配空间之后才可以进行数组的初始化，当然也可以直接初始化，系统将自动为数组分配一定的空间。如果不进行初始化，系统将给每个元素赋初值0。
例如，利用数组输出月份对应的天数的程序为：
public class GetDay
{
public static void main(String args[])
{
int day[]=new int[] {31,29,31,30,31,30,31,31,30,31,30,31};
int i;
for(i=0;i<12;i++)
{
System.out.println("2020年的"+(i+1)+"月有"+day[i]+"天。");
}
}
}
程序输出：
2020年的1月有31天。
2020年的2月有29天。
2020年的3月有31天。
2020年的4月有30天。
2020年的5月有31天。
2020年的6月有30天。
2020年的7月有31天。
2020年的8月有31天。
2020年的9月有30天。
2020年的10月有31天。
2020年的11月有30天。
2020年的12月有31天。
二维数组：
例如，输出3*4的零矩阵的程序为：
public class Matrix
{
public static void main(String args[])
{
int a[][]=new int[3][4];
int i,j;
for(i=0;i<a.length;i++)
{
for(j=0;j<a[i].length;j++)
{
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
程序输出：
0000
0000
0000
从这个程序可以看出，可以利用数组的length属性来获取数组的长度，从而实现对数组的遍历。当然，使用foreach语句则可以使遍历变得更加简便。
填充替换数组元素：
数组中的元素定义完成之后，可以通过Array类的fill()方法对数组中的元素进行替换，其有两种重载方式：
第一种用于全部替换：
import java.util.Arrays;
public class Swap
{
public static void main(String args[])
{
int a[]=new int[5];
Arrays.fill(a, 6);
int i;
for(i=0;i<a.length;i++)
{
System.out.println("数组a中第"+(i+1)+"个元素是："+a[i]);
}
}
}
程序输出：
数组a中第1个元素是：6
数组a中第2个元素是：6
数组a中第3个元素是：6
数组a中第4个元素是：6
数组a中第5个元素是：6
第二种用于指定范围替换：
fill(int [ ] a,int fromIndex,int toIndex,int value)
该方法将指定的int值分配给int型数组指定范围的每个元素，填充的范围从fromIndex一直到toIndex，如果fromIndex与toIndex的值相等，则范围为空；如果指定位置大于等于数组长度，则编译器会报错。
import java.util.Arrays;
public class Displace
{
public static void main(String args[])
{
int a[]=new int[] {1,2,3,4,5};
Arrays.fill(a,1,4,0);
int i;
for(i=0;i<a.length;i++)
{
System.out.println("数组a的第"+(i+1)+"个元素是："+a[i]);
}
}
}
程序输出：
数组a的第1个元素是：1
数组a的第2个元素是：0
数组a的第3个元素是：0
数组a的第4个元素是：0
数组a的第5个元素是：5
数组的复制：
Array类的copyOf()方法和copyOfRange()方法可以实现对数组的复制，前者是复制数组至指定长度（若超出原数组范围，则自动补0）；后者将指定数组的指定长度复制到一个新数组中。
import java.util.Arrays;
public class Copy
{
public static void main(String args[])
{
int a[]=new int[] {1,2,3,4,5};
int a1[]=Arrays.copyOf(a,6);
int a2[]=Arrays.copyOfRange(a,0,3);
int i;
System.out.println("测试copyOf()方法：");
for(i=0;i<a1.length;i++)
{
System.out.println(a1[i]);
}
System.out.println("\n测试copyOfRange()方法：");
for(i=0;i<a2.length;i++)
{
System.out.println(a2[i]);
}
}
}
程序输出：
测试copyOf()方法：
1
2
3
4
5
0
测试copyOfRange()方法：
1
2
3
对数组进行排序：
Array类的sort()方法可以实现对数组的排序，其有多种重载形式，可以对任意数组进行升序排序。
import java.util.Arrays;
public class Sort
{
public static void main(String args[])
{
int a[]=new int[] {3,8,1,4,10,5,7,6,2,9};
Arrays.sort(a);
int i;
for(i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
程序输出：
1
2
3
4
5
6
7
8
9
10
排序算法的实现：
说到排序，我们可以利用数组实现多种排序算法，如冒泡排序、选择排序、反转排序、快速排序等等。下面我们来看看这些算法在Java中的实现：
1.冒泡排序：
public class BubbleSort
{
public static void main(String args[]) //主方法
{
int a[]= {8,7,10,2,4,9,3,1,5,6};
BubbleSort sorter=new BubbleSort(); //创建对象
sorter.sort(a);
}
public void sort(int array[]) //冒泡排序方法
{
int i,j,t;
for(i=1;i<array.length;i++)
{
for(j=0;j<array.length-i;j++) //比较相邻的两个元素，较大数向后移
{
if(array[j]>array[j+1])
{
t=array[j]; //把第一个元素值保存到临时变量中
array[j]=array[j+1]; //把第二个元素值保存到第一个元素单元中
array[j+1]=t; //把临时变量保存到第二个元素中
}
}
}
show(array);
}
public void show(int array[]) //输出方法
{
for(int i : array) //遍历数组
{
System.out.print(" "+i);
}
System.out.println();
}
}
程序输出：
1 2 3 4 5 6 7 8 9 10
2.选择排序：
public class SelectSort
{
public static void main(String args[])
{
int array[]= {5,4,6,8,2,3,10,9,1,7};
SelectSort sorter=new SelectSort(); //对象
sorter.sort(array);
}
public void sort(int array[]) //选择排序方法
{
int i,j,k,t;
for(i=1;i<array.length;i++)
{
k=0;
for(j=1;j<=array.length-i;j++)
{
if(array[j]>array[k])
{
k=j;
}
}
t=array[array.length-i];
array[array.length-i]=array[k];
array[k]=t;
}
show(array);
}
public void show(int array[]) //输出方法
{
for(int i : array)
{
System.out.print(" "+i);
}
System.out.println();
}
}
程序输出：
1 2 3 4 5 6 7 8 9 10
3.反转排序：
public class ReverseSort
{
public static void main(String args[])
{
int array[]= {0,1,2,3,4,5,6,7,8,9,10};
ReverseSort sorter=new ReverseSort();
sorter.sort(array);
}
public void sort(int array[])
{
System.out.println("原数组：");
show(array);
int i,t,l;
l=array.length;
for(i=0;i<l/2;i++)
{
t=array[i];
array[i]=array[l-i-1];
array[l-i-1]=t;
}
System.out.println("反转后的数组：");
show(array);
}
public void show(int array[])
{
for(int i : array)
{
System.out.print(" "+i);
}
System.out.println();
}
}
程序输出：
原数组：
0 1 2 3 4 5 6 7 8 9 10
反转后的数组：
10 9 8 7 6 5 4 3 2 1 0
————————————————————————————————————————————————————
2020.6.28 【Day8】
Java中的权限修饰符有三种：public、private、protected，分别代表公有、私有、被保护。由于Java相较于C++多了包的概念，即同一个包包含的类和其他包包含的类它们之间是不能直接访问的，所以这些修饰符所代表的权限范围和C++中有所不同。详见下表：
当声明类的时候没有使用public、private、protected这些权限修饰符时，这个类会被系统自动设置成包存取范围，即只有一个包中的类才可以调用这个类的成员变量和成员方法。
Java语法规定，类的权限设定会约束类成员的权限设定。如果某个类被声明为private，而这个类中的某个成员却被声明为public，则其他类在调用这个类的public成员的时候仍然会受类的private的限制，而无法被直接调用。说的通俗一点就是下级服从上级。
this关键字：
this关键字用来代表本类对象的引用，this关键字被隐式地用于引用对象的成员变量和方法，例如：
private void setname(String name)
{
this.name=name; //将形参name的值赋给成员变量name
}
类的构造方法：
Java中类的构造方法类似于C++中类的构造函数。有两种构造方法：无参构造方法、有参构造方法。在无参构造方法中可以使用this关键字调用有参构造方法（只可以在无参构造方法中的第一句使用this调用有参构造方法）。
public class Constructor
{
public Constructor()
{
this("this调用有参构造方法");
System.out.println("无参构造方法");
}
public Constructor(String name)
{
System.out.println("有参构造方法");
}
}
static关键字：
静态数据与静态方法的作用通常是为了提供共享数据或方法，其以static声明并实现，需要使用时只需要直接使用类名调用这些静态成员即可。静态成员同样遵循着public、private、protected修饰符的约束。
在类的方法中的局部变量不能设置成ststic类型的，否则会发生错误。
如果在执行类时希望先执行类的初始化动作，则可以使用static定义一个静态区域static，则程序在被执行时会首先调用static块中的代码。
static
{
......
}
对象的引用：
拿书本类Book的一个对象book1举例，它的创建方式为：
Book book1=new Book();
其中Book是类名，book1是对象名，new在这里表示创建对象操作符。
对象的比较：
Java中有两种比较对象的方式，第一种是直接用“==”判断，第二种是调用String类的equals()方法判断。前者比较的是两个对象引用的地址是否相同，而后者用于比较两个对象引用所指的内容是否相等，要注意区分。
public class Compare
{
public static void main(String args[])
{
String c1=new String("123456");
String c2=new String("123456");
String c3=c1; //将c1对象的引用赋给c3
System.out.println("c2==c3:"+(c2==c3));
System.out.println("c2.equals(c3):"+(c2.equals(c3)));
}
}
程序输出：
c2==c3:false
c2.equals(c3):true
对象的销毁：
每个对象都有生命周期，当一个对象的生命周期结束时，分配给该对象的内存地址就需要回收。在其他面向对象的编程语言当中（如C++），我们需要手动回收废弃的对象，过程比较繁琐且易忘，容易发生内存占用的情况。但是在Java中有完整的垃圾回收机制，系统会自动回收无用内存，这也算是Java的优点之一。
嗯，真香。
Java虚拟机会将两种对象视为垃圾：
1）某一对象引用超过了其作用范围，则该对象被视为垃圾。
2）将某一对象赋值为NULL，则该对象被视为垃圾。
虽然垃圾回收机制优点众多，但其的作用范围是有限的，它只能回收由new操作符所创建的对象，而其余的对象无法被垃圾回收机制识别。对于没有使用new来创建的对象，我们可以使用Object类当中的finalize()方法。当然我们可以自己在类当中定义finalize()方法，则在垃圾回收时会首先调用自己定义的方法。
需要明确的是，即使有了垃圾回收机制和finalize()方法，它们也不是万能的。如果Java虚拟机的内存消耗殆尽，则所有的垃圾回收处理将不被执行。
这个时候则必须调用System.gc()方法来强制回收内存。
最后我写了一个矩形类，分别输出其面积与周长，以加深我对Java中类与对象的理解：
public class Rectangle //矩形类
{
private double height; //矩形的长
private double width; //矩形的宽
public Rectangle(double height,double width) //构造方法
{
this.height=height;
this.width=width;
}
public double square() //返回矩形面积
{
return height*width;
}
public double perimeter() //返回矩形周长
{
return 2*(height+width);
}
public static void main(String args[]) //主方法
{
Rectangle r=new Rectangle(3.5,4.5);
System.out.println("矩形的面积为："+r.square());
System.out.println("矩形的周长为："+r.perimeter());
}
}
程序输出：
矩形的面积为：15.75
矩形的周长为：16.0
————————————————————————————————————————————————————
2020.6.29 【Day9】
刚刚得到消息，小学期7月6号开始，真是猝不及防，看来得加快点进度了，争取在7月5号之前学到Java网络程序设计，以便和小学期的课程无缝衔接。
今天先来看看Java中的包装类。
在Java中不能定义基本类型（int,double等）的对象，但有时需要将基本类型视作对象来处理，此时就要用到每个基本类型的包装类。包装类的类名以及它们所对应的基本类型如下所示：
Byte —— byte
Short —— short
Integer —— int
Long —— long
Float —— float
Double —— double
Boolean —— boolean
Character —— char
其中，int和char类型的类名比较特殊，需要单独记忆。每个包装类当中都有许多方法，可以以不同的数据类型返回当前对象，这些方法的具体使用情况就不在这里逐一列举了。下面以几个例子来感受一下包装类的作用：
将字符变量转化为二进制、八进制、十六进制数字输出：
public class Charac
{
public static void main(String args[])
{
String s=Integer.toString(123); //将字符串类型转化为整型，并获取十进制表示
String s1=Integer.toBinaryString(123); //获取二进制表示
String s2=Integer.toOctalString(123); //获取八进制表示
String s3=Integer.toHexString(123); //获取十六进制表示
System.out.println("123的十进制表示为："+s);
System.out.println("123的二进制表示为："+s1);
System.out.println("123的八进制表示为："+s2);
System.out.println("123的十六进制表示为："+s3);
}
}
程序输出：
123的十进制表示为：123
123的二进制表示为：1111011
123的八进制表示为：173
123的十六进制表示为：7b
判断字符的大小写状态：
public class UpperOrLower
{
public static void main(String args[])
{
Character c1=new Character('A');
Character c2=new Character('a');
System.out.println(c1+"是大写字母："+Character.isUpperCase(c1));
System.out.println(c2+"是小写字母："+Character.isLowerCase(c2));
}
}
程序输出：
A是大写字母：true
a是小写字母：true
输出Integer类的常量值：
public class GetCon
{
public static void main(String args[])
{
int max=Integer.MAX_VALUE;
int min=Integer.MIN_VALUE;
int size=Integer.SIZE;
System.out.println("int类型可取的最大值是："+max);
System.out.println("int类型可取的最小值是："+min);
System.out.println("int类型的二进制位数是："+size);
}
}
程序输出：
int类型可取的最大值是：2147483647
int类型可取的最小值是：-2147483648
int类型的二进制位数是：32
下面再来看看Java中的数字处理类：
1.DecimalFormat类：
DecimalFormat类用于十进制数字格式化，其是NumberFormat的子类，它可以将一些数字格式化为整数、浮点数、百分数等等。
2.Math类：
Math类用于执行一些基本数学运算，其包含了众多数学运算方法。常用的方法如下：
1）三角函数方法
public static double sin(double a) //返回角的三角正弦
public static double cos(double a) //返回角的三角余弦
public static double tan(double a) //返回角的三角正切
public static double asin(double a) //返回一个值的反正弦
public static double acos(double a) //返回一个值的反余弦
public static double atan(double a) //返回一个值的反正切
public static double toRadians(double angdeg) //将角度转换为弧度
public static double toDegrees(double angrad) //将弧度转换为角度
public class TrigonometricFunction
{
public static void main(String[] args)
{
// 取90度的正弦
System.out.println("90度的正弦值：" + Math.sin(Math.PI / 2));
// 取0度的余弦
System.out.println("0度的余弦值：" + Math.cos(0));
// 取60度的正切
System.out.println("60度的正切值：" + Math.tan(Math.PI / 3));
// 取2的平方根与2商的反正弦
System.out.println("2的平方根与2的商的反正弦值："+Math.asin(Math.sqrt(2) / 2));
// 取2的平方根与2商的反余弦
System.out.println("2的平方根与2的商的反余弦值："+Math.acos(Math.sqrt(2) / 2));
// 取1的反正切
System.out.println("1的反正切值：" + Math.atan(1));
// 取120度的弧度值
System.out.println("120度的弧度值：" + Math.toRadians(120.0));
// 取π/2的角度
System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI / 2));
}
}
程序输出：
90度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
2的平方根与2的商的反正弦值：0.7853981633974484
2的平方根与2的商的反余弦值：0.7853981633974483
1的反正切值：0.7853981633974483
120度的弧度值：2.0943951023931953
π/2的角度值：90.0
2）指数函数方法
public static double exp(double a) //用于获取e的a次方
public static double log(double a) //用于取自然对数
public static double log10(double a) //用于取底数为10的对数
public static double sqrt(double a) //用于取a的平方根
public static double cbrt(double a) //用于取a的立方根
public static double pow(double a,double b) //用于取a的b次方
public class ExponentFunction
{
public static void main(String[] args)
{
// 取e的2次方
System.out.println("e的平方值：" + Math.exp(2));
// 取以e为底2的对数
System.out.println("以e为底2的对数值：" + Math.log(2));
// 取以10为底2的对数
System.out.println("以10为底2的对数值：" + Math.log10(2));
// 取4的平方根
System.out.println("4的平方根值：" + Math.sqrt(4));
// 取8的立方根
System.out.println("8的立方根值：" + Math.cbrt(8));
// 取2的2次方
System.out.println("2的2次方值：" + Math.pow(2, 2));
}
}
程序输出：
e的平方值：7.38905609893065
以e为底2的对数值：0.6931471805599453
以10为底2的对数值：0.3010299956639812
4的平方根值：2.0
8的立方根值：2.0
2的2次方值：4.0
3）取整函数方法
public static double ceil(double a) //返回大于等于参数的最小整数
public static double floor(double a) //返回小于等于参数的最大整数
public static double rint(double a) //返回与参数最接近的整数（偶数优先）
public static int round(float a) //将参数加上0.5后返回最近的整数
public static long round(double a) //同上，并将结果强制转换为long型
public class IntFunction
{
public static void main(String[] args)
{
// 返回第一个大于等于参数的整数
System.out.println("使用ceil()方法取整：" + Math.ceil(5.2));
// 返回第一个小于等于参数的整数
System.out.println("使用floor()方法取整：" + Math.floor(2.5));
// 返回与参数最接近的整数
System.out.println("使用rint()方法取整：" + Math.rint(2.7));
// 返回与参数最接近的整数
System.out.println("使用rint()方法取整：" + Math.rint(2.5));
// 将参数加上0.5后返回最接近的整数
System.out.println("使用round()方法取整：" + Math.round(3.4f));
// 将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型
System.out.println("使用round()方法取整：" + Math.round(2.5));
}
}
程序输出：
使用ceil()方法取整：6.0
使用floor()方法取整：2.0
使用rint()方法取整：3.0
使用rint()方法取整：2.0
使用round()方法取整：3
使用round()方法取整：3
4）取最大最小值、绝对值函数方法
public static double max(double a,double b) //取ab间的最大值
public static int min(int a,int b) //取ab间的最小值，并返回为不同类型
public static long min(long a,long b)
public static float min(float a,float b)
public static double min(double a,double b)
public static int abs(int a) //返回参数的绝对值
public static long abs(long a)
public static float abs(float a)
public static double abs(double a)
public class AnyFunction
{
public static void main(String[] args)
{
System.out.println("4和8较大者:" + Math.max(4, 8));
System.out.println("4.4和4较小者：" + Math.min(4.4, 4));
System.out.println("-7的绝对值：" + Math.abs(-7));
}
}
程序输出：
4和8较大者:8
4.4和4较小者：4.0
-7的绝对值：7
3.随机数类：
java.util.Random类可以通过实例化一个Random对象来创建一个随机数生成器。下面是几种常用的方法：
public int nextInt() //返回随机整数
public int nextInt(int n) //返回[0,n)区间的任意整数
public long nextLong() //返回随机长整型数
public boolean nextBoolean() //返回随机布尔型值
public float nextFloat() //返回随机浮点型值
public double nextDouble() //返回随机双精度值
public double nextGaussian() //返回概率密度为高斯分布的双精度值
import java.util.Random;
public class RandomDemo
{
public static void main(String[] args)
{
// 实例化一个Random类
Random r = new Random();
// 随机产生一个整数
System.out.println("随机产生一个整数:" + r.nextInt());
// 随机产生一个大于等于0小于10的整数
System.out.println("随机产生一个大于等于0小于10的整数：" + r.nextInt(10));
// 随机产生一个布尔型的值
System.out.println("随机产生一个布尔型的值：" + r.nextBoolean());
// 随机产生一个双精度型的值
System.out.println("随机产生一个双精度型的值：" + r.nextDouble());
// 随机产生一个浮点型的值
System.out.println("随机产生一个浮点型的值：" + r.nextFloat());
// 随机产生一个概率密度为高斯分布的双精度值
System.out.println("随机产生一个概率密度为高斯分布的双精度值：" + r.nextGaussian());
}
}
程序随机输出：
随机产生一个整数:-965332179
随机产生一个大于等于0小于10的整数：2
随机产生一个布尔型的值：true
随机产生一个双精度型的值：0.7186890522166023
随机产生一个浮点型的值：0.026343584
随机产生一个概率密度为高斯分布的双精度值：-0.5631686475413342
————————————————————————————————————————————————————
欲知后事如何，请点击下方链接：
【Java】学习笔记2——从小白到入门（技术提升篇）