一.常用类
1.Math类
Math 类提供了一序列基本数学运算和几何函数的方法。
Math类是final类,并且它的所有成员变量和成员方法都是静态的。jiduanz
常用的一些静态方法:
double pow (double a, double b) // 计算a的b次方 doublesqrt (double a) //计算给定值的平方根 int abs(int a) //计算int 类型值 a的绝对值,也接收 long、float 和 double 类型的参数 double ceil (double a)//返回大于等于a的最小整数的double值 double floor (double a) //返小于等于a的最小整数的double值 int max(int a, int b)//返回int 型值 a 和 b 中的较大值,也接收 long、float 和 double 类型的参数 int min(int a, int b)//返回a 和 b 中的较小值,也可接收 long、float 和 double 类型的参数 int round(float a);//四舍五入返回整数 double random()//返回带正号的double值,该值大于等于0.0且小于1.0 如下例: public class MathDemo { public static void main(String[] args) { double powResult=Math.pow(2,3); System.out.println("2的3次方为:"+powResult); System.out.println("8的平方根:"+Math.sqrt(8)); System.out.println("-7.35的绝对值是:"+Math.abs(-7.35)); System.out.println("8.1向上取整:"+Math.ceil(8.1)); System.out.println("9.9向下取整:"+Math.floor(9.9)); System.out.println("8.499四舍五入的结果:"+Math.round(8.499)); System.out.println("8.5四舍五入的结果:"+Math.round(8.5)); System.out.println("随机返回一个从0.0(包括)到1.0(不包括)值:"+Math.random()); int ran=(int)(Math.random()*16)+3; System.out.println("随机返回3到18的数字:"+ran); System.out.println("圆周率是:"+Math.PI); } }
2.Random类
常用方法: public int nextInt(int bound)
返回从0(包含)到bound(不包含)的一个“伪随机”整数值。
public class RandomDemo {
public static void main(String[] args) {
Random ran=new Random();
int result=ran.nextInt(16)+3;
System.out.println("随机返回3到18的数字:"+result);
System.out.println("随机返回boolean值:"+ran.nextBoolean());
}
}
3.System类
成员变量
System类内部包含in、out和err三个成员变量,分别代表标准输入流(键盘输入),标准输出流(显示器)和标准错误输出流(显示器)。
public static void main(String[] args) { System.out.println("正常输出信息..."); System.err.println("输出标准错误信息..."); int[] a = {1,2,3,4}; int[] b = new int[5]; System.arraycopy(a,1,b,3,2); // 数组拷贝 for(int x:b){ System.out.print(x+" "); } System.exit(0); // 退出程序 }
exit()方法:
格式:
public static void exit(int status)
该方法的作用是退出程序。其中status的值为0代表正常退出,非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
gc()方法:
格式:
public static void gc()
该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收,则取决于系统中垃圾回收算法的实现以及系统执行时的情况。垃圾回收时,会先调用finalize()方法,释放非java资源。
currentTimeMillis方法:
格式:
public static long currentTimeMillis()
以毫秒为单位返回从1970年1月1日午夜到当前时间的毫秒数。
4. Runtime类
作用:使应用程序与其运行的环境相关联。
通过使用getRuntime()静态方法获得实例。exec(String command)在单独的进程中执行指定的字符串命令,该方法返回Process对象,使用Process对象的destroy()方法可以杀掉进程。
public class RuntimeDemo {
public static void main(String[] args) {
Runtime rt= Runtime.getRuntime();
rt.gc(); // 显式请求JVM进行垃圾回收gc
System.out.println("当前JVM的内存总量是:"+rt.totalMemory()+"字节");
System.out.println("JVM试图使用的最大内存量:"+rt.maxMemory());
System.out.println("当前JVM的空闲内存量:"+rt.freeMemory());
try {
rt.exec("notepad");
rt.exec("calc");
Process qq=rt.exec("F:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe"); // 打开QQ进程
Scanner scan=new Scanner(System.in);
System.out.print("要关闭QQ吗?y/n");
String choice=scan.next();
if("y".equals(choice)){
qq.destroy(); // 销毁进程
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. Date类与SimpleDateFormat类
Date类:表示日期和时间。提供操作日期和时间各组成部分的方法。
SimpleDateFormat类
用于定制日期时间的格式。
Datedate= new Date(); //创建日期对象 SimpleDateFormatsdf=new SimpleDateFormat("yyyy-MM-ddHH:mm:ss");//定制日期格式 String now = sdf.format(date); System.out.println(now);
6. Calendar类
抽象类,用于设置和获取日期/时间数据的特定部分。Calendar类提供一些方法和静态字段来操作日历。
方法或属性 | 说明 |
int get(int field) | 返回给定日历字段的值 |
MONTH | 指示月 |
DAY_OF_MONTH | 指示一个月中的某天 |
DAY_OF_WEEK | 指示一个星期中的某天 |
public class CalendarDemo {
public static void main(String[] args) {
Calendar cal=Calendar.getInstance();
System.out.println("第几个月:"+(cal.get(Calendar.MONTH)+1));
System.out.println("当前月的第几天:"+cal.get(Calendar.DAY_OF_MONTH));
System.out.println("星期几:"+cal.get(Calendar.DAY_OF_WEEK));
System.out.println("今年的第几天:"+cal.get(Calendar.DAY_OF_YEAR));
System.out.println("*******************************");
}
}
二. 正则表达式
定义:正则表达式(regex)是使用字符串来描述、匹配一系列符合某个句法规则的字符串。
用途:匹配、切割、替换、获取字符串。
组成:正则表达式由一些普通字符和一些元字符组成。
元字符 | 描述 |
^ | 匹配输入字符串的开始位置 |
$ | 匹配输入字符串的结束位置 |
\d | 匹配一个数字字符。等价于[0-9] |
\D | 匹配一个非数字字符。等价于[^0-9] |
\s | 匹配任何空白字符,包括空格、制表符、换页符等等。等价于[ \n\r\t\f] |
\S | 匹配任何非空白字符。等价于[^\n\r\t\f] |
\w | 匹配包括下划线的任何单个字符。等价于"[A-Za-z0-9_]" |
\W | 匹配任何非单个字符。等价于“[^A-Za-z0-9_]” |
. | 匹配除“\r\n”之外的任何单个字符 |
{n} | n是一个非负整数。匹配确定的n次 |
{n,} | n是一个非负整数。至少匹配n次 |
{n,m} | m和n均为非负整数,其中n<=m。最少匹配n次且最多匹配m次 |
* | 匹配前面的子表达式零次或多次(大于等于0次) |
? | 匹配前面的子表达式零次或一次 |
+ | 匹配前面的子表达式一次或多次(大于等于1次) |
在Java中反斜线”\”有三种含义:
(1)反斜线后面可以加特定字符,组成所谓的“转义字符”。eg: \n \t 。
(2)用于取消元字符的意义,使元字符变为普通字符。eg: “\\” 代表”\”。
(3)用于组成正则表达式中的元字符。eg: “\d” 在正则表达式中代表“匹配一个数字字符”。
1.Pattern类与Matcher类
(1)Pattern类与Matcher类都在java.util.regex包中定义。
(2)Pattern类的对象代表正则表达式编译之后的对象;Matcher类主要用于执行验证。
(3)Pattern类的主要方法:
public static Pattern compile(String regex); public Matcher matcher(CharSequence input)
Matcher类的主要方法:
public boolean matches();
public class RegexMatch {
public static void main(String[] args) {
String birthday="1994-02-25";
String regex="\\d{4}-\\d{2}-\\d{2}";
Pattern pat=Pattern.compile(regex); // 将正则表达式封装到Pattern对象中
Matcher mat=pat.matcher(birthday); // 创建一个匹配器Matcher,该Matcher对象可以根据正则表达式判断传入的字符串是否符合要求
if(mat.matches()){
System.out.println("匹配成功!");
}else{
System.out.println("匹配失败...");
}
}
2.String类对正则表达式的支持
public boolean matches(String regex) //判断字符串是否与给定的正则表达式匹配。
public String replaceAll(String regex,String replacement) //字符串替换
public String[] split(String regex) //字符串拆分
public class StringRegex {
public static void main(String[] args) {
String str="hello1java22regex333python4444C55555";
if(str.matches("\\w+")){
System.out.println("匹配成功!");
}
System.out.println("替换后的字符串为:"+str.replaceAll("\\d+","#"));
String country="中国|美国|俄罗斯|德国";
String[] array=country.split("\\|");
for(String c:array){
System.out.print(c+" ");
}
}
补充:
正则表达式中的问号?有两种作用:第一种作用:重复前面表达式0次或1次。第二种作用:在表示次数的元字符后加上?代表取消默认的贪婪匹配模式,变为“非贪婪匹配模式”。
public class GreedyRegex {
public static void main(String[] args) {
String str="abbbbbbb";
System.out.println("贪婪模式匹配: "+str.replaceAll("ab+","#")); // "贪婪匹配"
System.out.println("非贪婪模式匹配: "+str.replaceAll("ab+?","#"));
}
}
三.枚举类型
枚举类型使用一组常量值来表示特定的数据集合,该集合中数据的数目确定(通常较少),且这些数据只能取预先定义的值。
2. Java枚举类型均自动继承java.lang.Enum类(该类继承了Object类)。
声明枚举类型:
[public] enum 枚举类型名称{ 枚举对象1,枚举对象2,…,枚举对象n ; }
获取枚举对象的两种方法:
方法一:取得单个枚举对象
枚举.对象名
方法二:取得全部枚举对象
枚举.values()
注意:枚举.values()返回的是一个对象数组,可以通过遍历该对象数组获取所有枚举对象。
package enumdemo;
public enum ColorEnum {
RED,GREEN,BLUE;
}
public class TestColor {
public static void main(String[] args) {
ColorEnum r=ColorEnum.RED;
System.out.println(r);
System.out.println("遍历所有枚举对象:");
for(ColorEnum c:ColorEnum.values()){
System.out.print(c+" ");
}
}
}
四.集合
1.定义:Java API所提供的一系列类的实例,可以用于动态存放多个对象。
Java集合框架提供了一套性能优良、使用方便的接口和类,它们位于java.util包中 。
特点:长度不固定,只能存储引用类型对象。
首先了解一下JAVA集合的框架:
(1)主接口有collection和Map接口;
(2)Collection有两个子接口,List和Set接口。
(3)ArrayList和LinkedList为两个实现类,继承list接口。HashSet和TreeSet为Set的两个实现类。
Collection 接口定义了存取对象的方法。两个常用的子接口。
注意:List 接口存储一组不唯一(可重复),有序(插入顺序)的对象 。Set 接口存储一组唯一(不可重复)的对象 。
Collection接口中定义了一些集合常用方法:
方法 | 说明 |
int size(); | 返回此collection中的元素数 |
boolean isEmpty(); | 判断此collection中是否包含元素。 |
boolean contains(Object obj); | 判断此collection是否包含指定的元素。 |
boolean add(Object element); | 向此collection中添加元素。 |
boolean remove(Object element); | 从此collection中移除指定的元素。 |
void clear(); | 移除些collection中所有的元素。 |
Iterator iterator(); | 返回在此collection的元素上进行迭代的迭代器 |
Object[] toArray(); | 把此collection转成数组。 |
public class CollectionsDemo {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
Collections.addAll(list,"Apple","Banana","Orange","Apple","Watermelon");
showList(list);
Collections.shuffle(list); // 打乱List集合中的元素
System.out.println("打乱之后:");
showList(list);
Collections.reverse(list); // 反转List集合
System.out.println("反转之后:");
showList(list);
}
public static void showList(List<String> list){
for(String str:list){
System.out.print(str+" ");
}
System.out.println();
}
}
实现类——ArrayList
ArrayList是使用数组结构实现的List集合。
优点: 对于使用索引取出元素有较好的效率 。它使用索引来快速定位对象。
缺点: 元素做删除或插入速度较慢 因为使用了数组,需要移动后面的元素以调整索引顺序。
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("apple");
list.add("banana");
list.add("orange");
list.add("apple"); // List可以添加重复元素
list.add("apple"); // List可以添加重复元素
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" "); // get(int index)方法是List接口扩展的方法
}
System.out.println();
System.out.println("**********增强for循环遍历**********");
for(String str:list){
System.out.print(str+" ");
}
System.out.println();
System.out.println("包含apple吗?"+list.contains("apple"));
System.out.println("删除之前的元素个数:"+list.size());
list.remove("apple");
System.out.println("删除之后的元素个数:"+list.size());
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+" "); // get(int index)方法是List接口扩展的方法
}
}
}
实现类——LinkedList
LinkedList是使用双向链表实现的集合。
优点:对频繁的插入或删除元素有较好的效率。
缺点:查询元素时,效率低,因为要从第一个元素查找。
public class LinkedListDemo {
public static void main(String[] args) {
System.out.println("模拟栈数据结构(先进后出FILO):");
LinkedList<String> list=new LinkedList<String>();
list.push("A");
list.push("B");
list.push("C");
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println(list.pop());
System.out.println("模拟队列数据结构(先进先出FIFO):");
list.add("A");
list.add("B");
list.add("C");
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
System.out.println(list.removeFirst());
}
}
提问:ArrayList和LinkedList分别在何时使用?
回答:ArrayList遍历元素和随机访问元素的效率比较高插入、删除等操作频繁时性能低下;LinkedList插入、删除元素时效率较高查找、遍历效率较低。
五.迭代器
定义:Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断,判断是否有内容,如果有内容则把内容取出。
Iterator对象称作迭代器,用以方便的实现对集合内元素的遍历操作。
所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。
Iterator it = coll.iterator();
while(it.hasNext()){
it.next();
}
package iterator;
import java.util.*;
public class IteratorDemo {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"China","America","Japan","China","France");
Iterator<String> iter=list.iterator(); // 返回List集合的迭代器
// 通过迭代器遍历集合
while(iter.hasNext()){
System.out.print(iter.next()+" ");
}
}
}
六. 泛型
定义:是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,
就像方法的形式参数是运行时传递的值的占位符一样。
泛型的好处:解决了类型安全的问题(运行期出现“java.lang.ClassCastException”异常)。
泛型类:
class Gen<T> {
private T ob; // 定义泛型成员变量
public Gen(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showType() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
受限泛型:
1. 设置上限
类名称<? extends 上限类>
只能接收上限类对象或其子类对象
2. 设置下限
类名称<? super 下限类>
接收下限类对象或其父类对象
注意:若定义泛型类,可以将?设置为泛型标识。
七.Set接口的实现类
Set接口没有提供Collection接口额外的方法,但实现Set接口的集合类中的元素是不可重复的。
1.HashSet的存储原理:
根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引,把对象存放在一个叫散列表的相应位置(表元)中。
(1)如果对应的位置没有其它元素,就只需要直接存入。
(2)如果该位置有元素了,会将新对象跟该位置的所有对象进行比较(调用equals()),以查看是否已经存在了:还不存在就存放,已经存在就不存储。
HashSet集合的特点及使用技巧:
(1)HashSet不保存元素的加入顺序。
(2)HashSet接口存、取、删对象都有很高的效率。
(3)对于要存放到HashSet集合中的对象,对应的类可以重写hashCode(Object obj)方法和equals()以实现对象相等规则的编写。
package set.hashset;
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
HashSet<String> set=new HashSet<String>();
set.add("apple");
set.add("banana");
set.add("orange");
set.add("apple");
set.add("apple");
for(String str:set){
System.out.print(str+" ");
}
}
2.Treeset集合的特点:可以对加入其中的元素进行排序。但前 提是,必须指定排序规则。
构造方法: public TreeSet()
如果使用TreeSet的无参构造实例化TreeSet集合,则加入到TreeSet集合中的元素所对应的类必须实现java.lang. Comparable<T>接口,
复写其中的int compareTo(T o)方法,并在方法中编写排序规则。
在Comparable<T>接口的compareTo(T o)方法中,指定排序规则(以升序为例):
public int compareTo(Girl girl){
if(this.xxx>girl.xxx){
return 1;
}else if(this.xxx<girl.xxx){
return -1;
}else{
return 0;
}
}
TreeSet比较排序的过程,已经对重复元素去重了。
转载于:https://blog.51cto.com/13531757/2057955