Java小白的干货铺子（五）

最新推荐文章于 2022-11-13 22:33:17 发布

weixin_34235135

最新推荐文章于 2022-11-13 22:33:17 发布

阅读量134

点赞数

原文链接：http://blog.51cto.com/13531757/2057955

版权

一.常用类

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

weixin_34235135

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java小白的干货铺子（五）

一.常用类1.Math类 Math 类提供了一序列基本数学运算和几何函数的方法。 Math类是final类，并且它的所有成员变量和成员方法都是静态的。jiduanz 常用的一些静态方法：doublepow(doublea,doubleb)//计算a的b次方doublesqrt(doublea)//计算给定值的平方根intabs(int...
复制链接

扫一扫