Java代码常用功能实现总结（一）

小强签名设计

已于 2024-06-26 18:27:30 修改

阅读量5.2k

点赞数 7

分类专栏： Java 文章标签： java 代码总结常用功能

于 2017-10-22 12:22:46 首次发布

本文链接：https://blog.csdn.net/m0_37739193/article/details/78309225

版权

Java 专栏收录该内容

39 篇文章 2 订阅

订阅专栏

文章目录

1. 获取当前系统时间：

SimpleDateFormat dfms = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");//设置带毫秒的日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
System.out.println(df.format(new Date()));

运行结果：
2017-10-22 12:18:37

(1) 时间戳（精确到秒为10位）转换为日期格式：

df.format(new Date(Long.valueOf(1538209477 + "000")));

运行结果：
2018-09-29 16:24:37

(2) 日期格式转换为时间戳：

// 步骤1：创建Simpledateformat对象
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 第二步:Date对象的分析时间字符串
Date date = df.parse("2023-08-31 17:46:43");
// 第三步:创建一个Calendar对象，并设置日期和时间
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
// 第四步:将Date对象转换为时间戳
long timestamp = calendar.getTimeInMillis();
System.out.println("时间字符串：2022-01-01 00:00:00");
System.out.println("时间戳：" + timestamp);

运行结果：
时间戳：1693475203000

(3) 不同时间格式相互转换：

SimpleDateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");
Date date = df.parse("1965-09-20 00:00:00");
System.out.println(df2.format(date));

运行结果：
1965-09-20

补充：日期和时间模式

字母	说明
G	显示时代/纪元字符串(如：AD)
y	年(如：2018年表示为2018)
yy	年(如：2018年表示为18)
M	将月份显示为不带前导零的数字(如：一月表示为1，十二月表示为12)
MM	将月份显示为带前导零的数字(如：一月表示为01，十二月表示为12)
MMM	将月份显示为英文缩写形式(如：Jan)
MMMM	将月份显示为完整月份名(如：January)
E	将星期显示为英文缩写形式(如：Sun)
EEEE	将星期显示为完整月份名(如：Sunday)
d	将日显示为不带前导零的数字(如：1、23)
dd	将日显示为带前导零的数字(如：01、23)
h	使用12小时制将小时显示为不带前导零的数字(如：凌晨和下午一点都表示为1)
hh	使用12小时制将小时显示为带前导零的数字(如：凌晨和下午一点都表示为01)
H	使用24小时制将小时显示为不带前导零的数字(如：凌晨一点表示为1，下午一点表示为13)
HH	使用24小时制将小时显示为带前导零的数字(如：凌晨一点表示为01，下午一点表示为13)
K	一天中的小时数，和h的区别就是h表示的范围为1-12，K表示的范围为0-11
k	一天中的小时数，和H的区别就是H表示的范围为0-23，K表示的范围为1-24
m	将分钟显示为不带前导零的数字(如：12:1:15)
mm	将分钟显示为带前导零的数字(如：12:01:15)
s	将秒显示为不带前导零的数字(如：12:15:5)
ss	将秒显示为带前导零的数字(如：12:15:05)
S	毫秒数(如：978)
z	时区(如：CST)
Z	时区偏移量(如：+0800)
w	年中的周数(如：2018-12-23输出结果为52)，ww则带前导零的数字
W	月份中的周数，会根据实际情况来算(如：2018-12-23输出结果为5)，WW则带前导零的数字(如：05)
F	月份中的星期，会把这个月总共过的天数除以7(如：2018-12-23输出结果为4)，FF则带前导零的数字
D	该年的第几天(如：2018-12-23输出结果为357)，DD则带前导零的数字
a	am/pm标记(如：AM、PM)

a. 时间格式: “Aug 28, 2015 6:8:30 PM”， 模式: “MMM d, yyyy h:m:s aa”
SimpleDateFormat dateFormat = new SimpleDateFormat("MMM d, yyyy h:m:s aa", Locale.ENGLISH);
Date date = dateFormat.parse("Aug 28, 2015 6:8:30 PM");

b. 时间格式: “Fri Aug 28 18:08:30 CST 2015”， 模式: “EEE MMM d HH:mm:ss ‘CST’ yyyy”
SimpleDateFormat dateFormat = new SimpleDateFormat("EEE MMM d HH:mm:ss 'CST' yyyy", Locale.ENGLISH);
Date date = dateFormat.parse("Fri Aug 28 18:08:30 CST 2015");

c. 时间格式: “Wednesday,October 12,2016”， 模式: “EEEE,MMMM dd,yyyy”
SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE,MMMM dd,yyyy", Locale.ENGLISH);
Date date = dateFormat.parse("Wednesday,October 12,2016");

注：我们在做时间格式转换时，主要是找对匹配时间格式的模式；另外，英文格式的时间转换时需要带上Locale.ENGLISH，否则显示的是中文，因为它默认的是本地化的设置，除非你的操作系统是英文的，总之时间转换时需要时间格式与模式保持一致。

2. 获取当前时间戳：

(1)方法一
System.currentTimeMillis();
(2)方法二
Calendar.getInstance().getTimeInMillis();
(3)方法三
new Date().getTime();

补充：获取时间戳三种方法执行效率比较

import java.util.Calendar;
import java.util.Date;
 
public class TimeTest {
    private static long _TEN_THOUSAND=10000;
    public static void main(String[] args) {
        long times=1000*_TEN_THOUSAND;
        long t1=System.currentTimeMillis();
        testSystem(times);
        long t2=System.currentTimeMillis();
        System.out.println(t2-t1);
 
        testCalander(times);
        long t3=System.currentTimeMillis();
        System.out.println(t3-t2);
 
        testDate(times);
        long t4=System.currentTimeMillis();
        System.out.println(t4-t3);
    }
 
    public static void testSystem(long times){
        for(int i=0;i<times;i++){
            long currentTime=System.currentTimeMillis();
        }
    }
 
    public static void testCalander(long times){
        for(int i=0;i<times;i++){
            long currentTime=Calendar.getInstance().getTimeInMillis();
        }
    }
 
    public static void testDate(long times){
        for(int i=0;i<times;i++){
            long currentTime=new Date().getTime();
        }
    }
 
}

执行结果：
43
1885
45
Calendar.getInstance().getTimeInMillis() 这种方式速度最慢，这是因为Canlendar要处理时区问题会耗费较多的时间。

Python：

import time
print (time.time())
print(int(round(time.time()*1000)))
print(int(time.time()))

运行结果：
1513776456.43
1513776456440
1513776456

疑惑：java上面的三种方法获取的时间戳都是13位的，而python用自带的time模块获取的却是1513776456.43，还得自己转换成10位或13位的

解答：时间戳的位数是根据算法计算的，没有固定的位数。可信时间戳计算出来的电子文件的数字指纹是40位~
由于精度不同，导致长度不一致，直接转换错误。 JAVA时间戳长度是13位，如：1294890876859 PHP时间戳长度是10位（不知道js默认是多少位，但是在工作中python传给js的时间戳还必须是13位，10位的解析不出来），如：1294890859 php echo date！

3. Java8 遍历输出日期

在 Java8 之前，要遍历输出日期需要使用传统的 Date 类或者 Calendar 类，操作繁琐不直观。然而，Java8 引入了新的日期时间 API，使得日期的处理更加简单和灵活。本文将介绍如何使用 Java8 的新日期时间API遍历并输出日期。

在 Java8 中，引入了 java.time 包，其中包括了一系列处理日期和时间的类。其中最重要的几个类有：

LocalDate：表示日期，不包含时间信息
LocalTime：表示时间，不包含日期信息
LocalDateTime：表示日期和时间
ZonedDateTime：表示带有时区的日期和时间

这些类提供了丰富的方法来操作和计算日期，例如获取年、月、日等信息，比较日期的先后顺序，计算日期间隔等等。

在 Java8 中，可以使用 for 循环或者流式操作来遍历输出日期。以下是两种常见的方式。

（1）使用for循环遍历日期：

        LocalDate startDate = LocalDate.of(2022, 10, 1);
        LocalDate endDate = LocalDate.of(2023, 1, 1);

        for (LocalDate date = startDate; date.isBefore(endDate); date = date.plusDays(1)) {
            String dateStr = date.toString();
            System.out.println(dateStr);
        }

上述代码中，我们使用 LocalDate.of() 方法创建了起始日期和结束日期。然后使用一个 for 循环，初始化日期为起始日期，每次循环更新日期为下一天，直到日期等于结束日期为止。在循环内部，我们可以对日期进行任何操作，例如输出日期，进行其他逻辑处理等。

注意：循环里会缺失结束时间，所以如果想要结束时间的话，结束时间你就多写一天。

（2）使用流式操作遍历日期：

        LocalDate startDate = LocalDate.of(2022, 1, 1);
        LocalDate endDate = LocalDate.of(2022, 12, 31);

        Stream.iterate(startDate, date -> date.plusDays(1))
                .limit(ChronoUnit.DAYS.between(startDate, endDate))
                .forEach(System.out::println);

上述代码中，我们使用 Stream.iterate() 方法生成一个日期流，起始日期为 startDate，每次生成的日期为上一日期加一天。然后使用 limit() 方法限制日期数量为起始日期和结束日期之间的天数差。最后使用 forEach() 方法遍历日期流，并输出日期。

这种方式使用了流式操作，相比于传统的for循环更加简洁和直观。

参考：java8 遍历输出日期

（3）老的方式：
参考：java 日期字符串遍历

String startDateString = "2023-11-01";  // 起始日期字符串
String endDateString = "2023-11-10";    // 结束日期字符串
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
// 将日期字符串解析为日期对象
Date startDate = dateFormat.parse(startDateString);
Date endDate = dateFormat.parse(endDateString);
Calendar calendar = Calendar.getInstance();
calendar.setTime(startDate);

while (calendar.getTime().before(endDate) || calendar.getTime().equals(endDate)) {
    // 在每个日期上执行操作
    // ...
    Date date=new Date();
    date=calendar.getTime(); //这个时间就是日期往后推一天的结果
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    String dateString = formatter.format(date);

    // ...

    // 增加一天
    calendar.add(Calendar.DAY_OF_MONTH, 1);
}

4. 字符串 String 的日期比较大小的方式：

String 型的日期通过 compareTo() 来比较，因为 String 实现了 comparable 接口：endDate.compareTo(startDate) 结果 >0 说明前者晚于后者。

String startDate="2020-11-13 00:00:00";

//当前时间endDate 是2020-11-14 09:52:41
String endDate= new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date());
// return 1，即 endDate>startDate
System.out.println(endDate.compareTo(startDate));

注意：比较的字符串格式要一致，yyyy-MM-dd hh:mm:ss 和 yyyyMMddhhmmss 格式是不一样的，这么比较结果肯定不对。

参考：Java日期比较大小的几种方式

4. 获取主机名和IP

InetAddress a=InetAddress.getLocalHost();
String localname=a.getHostName();
String localip=a.getHostAddress();
System.out.println("本机名称是：" + localname);
System.out.println("本机的ip是 ：" + localip);
System.out.println(InetAddress.getLocalHost());

运行结果：
本机名称是：h66
本机的ip是 ：192.168.205.66
h66/192.168.205.66

5. new String 用法：

byte[] bytes = "hui".getBytes(); //String转bytes
String receiveText = new String( bytes,1,2); //bytes转String
System.out.println(receiveText);

运行结果：
ui

6. ByteBuffer和String的互相转换：

String hui = "hehe";
ByteBuffer buffer = ByteBuffer.wrap(hui.getBytes());
Charset charset = Charset.forName("UTF-8");
CharsetDecoder decoder = charset.newDecoder();
CharBuffer charBuffer = decoder.decode(buffer.asReadOnlyBuffer());
System.out.println(buffer);
System.out.println(charBuffer.toString());

运行结果：
java.nio.HeapByteBuffer[pos=0 lim=4 cap=4]
hehe

7. int和string相互转换：

int -> String：
int i=12345;
String s="";
第一种方法：s=i+"";
第二种方法：s=String.valueOf(i);


String -> int或long：
s="12345";
int i;
第一种方法：i=Integer.parseInt(s);或Long.parseInt(s)
第二种方法：i=Integer.valueOf(s).intValue();或Long.valueOf(s).longValue()

这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？答：
第一种方法：s=i+""; //会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象
第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象

8. 把多个json放到list中：

		List<String> keysList1 = new ArrayList<>();
		JSONObject json1 = new JSONObject();
		json1.put("littleTitle", "你爱谁");
		json1.put("text", "小强签名设计");
		keysList1.add(json1.toString());
		JSONObject json2 = new JSONObject();
		json2.put("littleTitle", "我爱谁");
		json2.put("text", "你猜");
		keysList1.add(json2.toString());
		System.out.println("keysList11-->"+keysList1);

运行结果：
keysList11-->[{"littleTitle":"你爱谁","text":"小强签名设计"}, {"littleTitle":"我爱谁","text":"你猜"}]

9. 解析list中的json：

    public static void main(String[] args) {
        String data = "[{\"ID\":\"121\",\"DWDM\":\"aaaasss\"},{\"ID\":\"121\",\"DWDM\":\"aaaasss\"}]";
        JSONArray jsonArray = JSONArray.fromObject(data);
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject dd = JSONObject.fromObject(jsonArray.get(i).toString());
            System.out.println("dd-->"+dd);
        }
    }

运行结果：
dd-->{"ID":"121","DWDM":"aaaasss"}
dd-->{"ID":"121","DWDM":"aaaasss"}

10. List集合去除重复数据：

import java.util.*;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class printt {
	public static void main(String[] args) {
		List<String> strs = new ArrayList<String>();
		String str2 = "world";
		String str1 = "hello";
		String str3 = "world";
		strs.add(str1);// 通过add方法
		strs.add(str2);
		strs.add(str3);
		System.out.println(removeDuplicate(strs));
		System.out.println(removeDuplicate1(strs));
		System.out.println(removeDuplicate3(strs));
		removeDuplicate4(strs);

		// 可用于效率测试
		final List<String> list = new ArrayList<String>();
		for (int i = 0; i < 1000; i++) {
			list.add("haha-" + i);
		}

		long time = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			removeDuplicate2(list);
		}
		long time1 = System.currentTimeMillis();
		System.out.println("time1:" + (time1 - time));
	}

	public static List removeDuplicate(List list) {
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = list.size() - 1; j > i; j--) {
				if (list.get(j).equals(list.get(i))) {
					list.remove(j);
				}
			}
		}
		return list;
	}

	// 利用HashSet不能添加重复数据的特性
	public static List removeDuplicate1(List<String> list) {
		// 如果对list添加顺序无要求则可直接用
		// HashSet set = new HashSet(list);
		// list.clear();
		// list.addAll(set);

		// 如果对list添加顺序有要求的话，由于HashSet不能保证添加顺序，所以只能作为判断条件
		HashSet<String> set = new HashSet<String>();
		List<String> result = new ArrayList<String>();
		for (String str : list) {
			if (set.add(str)) {
				result.add(str);
			}
		}
		list.clear();
		list.addAll(result);
		return list;
	}

	// 利用LinkedHashSet不能添加重复数据并能保证添加顺序的特性
	private static void removeDuplicate2(List<String> list) {
		LinkedHashSet<String> set = new LinkedHashSet<String>(list);
		/*
		 * 或者： LinkedHashSet<String> set = new LinkedHashSet<String>();
		 * set.addAll(list);
		 */
		list.clear();
		list.addAll(set);
		// System.out.println(list);
	}

	// 利用List的contains方法循环遍历
	public static List removeDuplicate3(List list) {
		List listTemp = new ArrayList();
		for (int i = 0; i < list.size(); i++) {
			if (!listTemp.contains(list.get(i))) {
				listTemp.add(list.get(i));
			}
		}
		return listTemp;
	}

	// 删除ArrayList中重复元素，保持顺序
	public static void removeDuplicate4(List list) {
		Set set = new HashSet();
		List newList = new ArrayList();
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			Object element = iter.next();
			if (set.add(element))
				newList.add(element);
		}
		list.clear();
		list.addAll(newList);
		System.out.println(list);
	}
}

运行结果：
[hello, world]
[hello, world]
[hello, world]
[hello, world]
time1:1396

参考：
https://www.cnblogs.com/cainiao-Shun666/p/7911142.html
https://blog.csdn.net/u012156163/article/details/78338574

11. 判断数组中是否包含某个元素

在java中，我们如何判断一个未排序数组中是否包含一个特定的值？这在java中是一个频繁非常实用的操作。那么什么样的方法才是最高效的方式？

使用List：
public static boolean useList(String[] arr, String targetValue) {
    return Arrays.asList(arr).contains(targetValue);}

使用Set：
public static boolean useSet(String[] arr, String targetValue) {
    Set<String> set = new HashSet<String>(Arrays.asList(arr));
    return set.contains(targetValue);}

使用循环判断：
public static boolean useLoop(String[] arr, String targetValue) {
    for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }
    return false;}
    
使用Arrays.binarySearch()：
优点：使用二分查找法，效率快捷。
缺点：查询的数组必须是有序的，如果不是有序的话，使用此方法是没有用的。
public static boolean useArraysBinarySearch(String[] arr, String targetValue) { 
    int a =  Arrays.binarySearch(arr, targetValue);
    if(a >= 0)
        return true;
    else
        return false;}
        
时间复杂度
下面的代码可以大概的得出各种方法的时间成本。基本思想就是从数组中查找某个值，数组的大小分别是5、1k、10k。这种方法得到的结果可能并不精确，但是是最简单清晰的方式。
使用一个长度为5的数据：
public static void main(String[] args) {
    String[] arr = new String[] {  "CD",  "BC", "EF", "DE", "AB"};

    //use list
    long startTime = System.nanoTime();
    for (int i = 0; i < 100000; i++) {
        useList(arr, "A");
    }
    long endTime = System.nanoTime();
    long duration = endTime - startTime;
    System.out.println("useList:  " + duration / 1000000);

    //use set
    startTime = System.nanoTime();
    for (int i = 0; i < 100000; i++) {
        useSet(arr, "A");
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println("useSet:  " + duration / 1000000);

    //use loop
    startTime = System.nanoTime();
    for (int i = 0; i < 100000; i++) {
        useLoop(arr, "A");
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println("useLoop:  " + duration / 1000000);

//	    String[] array = {"AB","EF","GH"};
//	    System.out.println(Arrays.binarySearch(array,"EF"));
    //use Arrays.binarySearch()
    startTime = System.nanoTime();
    for (int i = 0; i < 100000; i++) {
        useArraysBinarySearch(arr, "A");
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println("useArrayBinary:  " + duration / 1000000);}
运行结果：
useList:  13
useSet:  72
useLoop:  5
useArraysBinarySearch:  9

使用一个长度为1k的数组
String[] arr = new String[1000];
Random s = new Random();for(int i=0; i< 1000; i++){
    arr[i] = String.valueOf(s.nextInt());}
结果：
useList:  112
useSet:  2055
useLoop:  99
useArrayBinary:  12

使用一个长度为10k的数组
String[] arr = new String[10000];
Random s = new Random();for(int i=0; i< 10000; i++){
    arr[i] = String.valueOf(s.nextInt());}
结果：
useList:  1590
useSet:  23819
useLoop:  1526
useArrayBinary:  12

除了以上几种以外，Apache Commons类库中还提供了一个ArrayUtils类，可以使用其contains方法判断数组和值的关系。

import org.apache.commons.lang3.ArrayUtils;
public static boolean useArrayUtils(String[] arr, String targetValue) {
    return ArrayUtils.contains(arr,targetValue);}
同样使用以上几种长度的数组进行测试，得出的结果是该方法的效率介于使用集合和使用循环判断之间（有的时候结果甚至比使用循环要理想）。

useList:  323
useSet:  3028
useLoop:  141
useArrayBinary:  12
useArrayUtils:  181
-------
useList:  3703
useSet:  35183
useLoop:  3218
useArrayBinary:  14
useArrayUtils:  3125
其实，如果查看ArrayUtils.contains的源码可以发现，他判断一个元素是否包含在数组中其实也是使用循环判断的方式。

部分代码如下：
    if(array == null) {
        return -1;
    } else {
        if(startIndex < 0) {
            startIndex = 0;
        }
        int i;
        if(objectToFind == null) {
            for(i = startIndex; i < array.length; ++i) {
                if(array[i] == null) {
                    return i;
                }
            }
        } else if(array.getClass().getComponentType().isInstance(objectToFind)) {
            for(i = startIndex; i < array.length; ++i) {
                if(objectToFind.equals(array[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

所以，相比较之下，我更倾向于使用ArrayUtils工具类来进行一些合数祖相关的操作。毕竟他可以让我少写很多代码（因为自己写代码难免有Bug，毕竟apache提供的开源工具类库都是经过无数开发者考验过的），而且，效率上也并不低太多。

参考：
https://www.programcreek.com/2014/04/check-if-array-contains-a-value-java/
https://www.cnblogs.com/zrbfree/p/6023894.html

12. 遍历Map的四种方法

（来自http://www.cnblogs.com/kristain/articles/2033566.html）

public static void main(String[] args) {
	Map<String, String> map = new HashMap<String, String>();
	map.put("1", "value1");
	map.put("2", "value2");
	map.put("3", "value3");
	  
	//第一种：普遍使用，二次取值
	System.out.println("通过Map.keySet遍历key和value：");
	for (String key : map.keySet()) {
		System.out.println("key= "+ key + " and value= " + map.get(key));
	}
	  
	//第二种
	System.out.println("通过Map.entrySet使用iterator遍历key和value：");
	Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
	while (it.hasNext()) {
		Map.Entry<String, String> entry = it.next();
		System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
	}
	  
	//第三种：推荐，尤其是容量大时
	System.out.println("通过Map.entrySet遍历key和value");
	for (Map.Entry<String, String> entry : map.entrySet()) {
		System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
	}

	//第四种
	System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
	for (String v : map.values()) {
		System.out.println("value= " + v);
	}
}

参考：http://blog.csdn.net/luanlouis/article/details/43017071

13. 除去字符串(String)中的换行字符(\r \n \t)：

String hui = "'ab cd" + "\n" + "efg'";
System.out.println("转换前："+hui);
hui = hui.replaceAll("\r|\n", "");
System.out.println("转换后："+hui);

运行结果：
转换前：'ab cd
efg'
转换后：'ab cdefg'

补充：

例2：
System.out.println("\\r 输出："+"abc"+"\r"+"abc");
System.out.println("\\n 输出："+"abc"+"\n"+"abc");
以上两句在控制台输出的格式是一样的：
\r输出：abc
abc
\r输出：abc
abc

那么他们有什么区别呢？
例3：
String hui = "'ab cd" + "\n\r" + "efg'";
System.out.println("转换前："+hui);
hui = hui.replaceAll("\r|\n", "");
System.out.println("转换后："+hui);
运行结果：
转换前：'ab cd

efg'
转换后：'ab cdefg'

可以看出\r表示回车，\n表示另起一行（\r 叫回车 Carriage Return  ；\n 叫新行 New Line）
我们可以再做一个实验：
String hui = "'ab cd" + "\r\n" + "efg'";
System.out.println("转换前："+hui);
hui = hui.replaceAll("\r|\n", "");
System.out.println("转换后："+hui);
运行结果:
转换前：'ab cd
efg'
转换后：'ab cdefg'

注：
trim()用来去首尾的空格符
\n 换行(\u000a)
\t 水平制表符(\u0009)
\s 空格(\u0008)
\r 回车(\u000d)

14. System.getProperty(“属性名”)方法的使用：

（参考自：http://blog.csdn.net/wodewutai17quiet/article/details/68946890）

System.out.println("操作系统的名称："+System.getProperty("os.name"));	//Windows 8
System.out.println("操作系统的架构："+System.getProperty("os.arch"));	//amd64
System.out.println("操作系统的版本："+System.getProperty("os.version"));	//6.2
System.out.println("Java 运行时环境版本："+System.getProperty("java.version"));	//1.7.0_25
System.out.println("Java 运行时环境供应商："+System.getProperty("java.vendor"));	//Oracle Corporation
System.out.println("Java 供应商的 URL："+System.getProperty("java.vendor.url"));	//http://java.oracle.com/
System.out.println("Java 安装目录："+System.getProperty("java.home"));	//C:\Program Files\Java\jdk1.7.0_25\jre
System.out.println("Java 虚拟机规范版本："+System.getProperty("java.vm.specification.version"));	//1.7
System.out.println("Java 虚拟机规范供应商："+System.getProperty("java.vm.specification.vendor"));	//Oracle Corporation
System.out.println("Java 虚拟机规范名称："+System.getProperty("java.vm.specification.name"));	//Java Virtual Machine Specification
System.out.println("Java 虚拟机实现版本："+System.getProperty("java.vm.version"));	//23.25-b01
System.out.println("Java 虚拟机实现供应商："+System.getProperty("java.vm.vendor"));	//Oracle Corporation
System.out.println("Java 虚拟机实现名称："+System.getProperty("java.vm.name"));	//Java HotSpot(TM) 64-Bit Server VM
System.out.println("Java 运行时环境规范版本："+System.getProperty("java.specification.version"));	//1.7
System.out.println("Java 运行时环境规范供应商："+System.getProperty("java.specification.vendor"));	//Oracle Corporation
System.out.println("Java 运行时环境规范名称："+System.getProperty("java.specification.name"));	//Java Platform API Specification
System.out.println("Java 类格式版本号："+System.getProperty("java.class.version"));	//51.0
System.out.println("Java 类路径："+System.getProperty("java.class.path"));
System.out.println("加载库时搜索的路径列表："+System.getProperty("java.library.path"));
System.out.println("默认的临时文件路径："+System.getProperty("java.io.tmpdir"));
System.out.println("要使用的 JIT 编译器的名称："+System.getProperty("java.compiler"));
System.out.println("一个或多个扩展目录的路径："+System.getProperty("java.ext.dirs"));
System.out.println("文件分隔符（在 UNIX 系统中是“/”）："+System.getProperty("file.separator"));
System.out.println("路径分隔符（在 UNIX 系统中是“:”）："+System.getProperty("path.separator"));
System.out.println("行分隔符（在 UNIX 系统中是“/n”）："+System.getProperty("line.separator"));
System.out.println("用户的账户名称："+System.getProperty("user.name"));
System.out.println("用户的主目录："+System.getProperty("user.home"));
System.out.println("用户的当前工作目录："+System.getProperty("user.dir"));

15. 获取昨天，上个星期一，本月开始时间：

    	//昨天
    	Date date=new Date();//取时间
    	Calendar calendar = new GregorianCalendar();
    	calendar.setTime(date);
    	calendar.add(calendar.DATE,-1);//把日期往后增加一天.整数往后推,负数往前移动
    	date=calendar.getTime(); //这个时间就是日期往后推一天的结果
    	SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
    	String dateString = formatter.format(date);
    	System.out.println(dateString);
    	
    	//上个星期一
//    	Calendar cal = Calendar.getInstance();
//    	int n = cal.get(Calendar.DAY_OF_WEEK) - 1;
//    	if (n == 0) {
//    	    n = 7;
//    	}
//    	cal.add(Calendar.DATE, -(7 + (n - 1)));// 上周一的日期
//    	Date monday = cal.getTime();
//    	SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
//    	String dateString = formatter.format(monday);
//    	System.out.println(dateString);
    	
    	//本月第一天
//    	Calendar cal_1=Calendar.getInstance();//获取当前日期 
//    	cal_1.add(Calendar.MONTH, -1);
//    	cal_1.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
//    	SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
//    	String firstDay = formatter.format(cal_1.getTime());
//    	System.out.println(firstDay);

参考：https://zhidao.baidu.com/question/523653874220755605.html

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date nowDate = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(nowDate);

		calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
		Date updateDate5 = calendar.getTime();
		System.out.println(updateDate5.getTime() + "往前推1天的时间=" + sdf.format(updateDate5));
		System.out.println(updateDate5.getTime() / 1000 + "往前推1天的时间=" + sdf.format(updateDate5));
		Long time = 1537845150178L;
		System.out.println(System.currentTimeMillis() - time < 1 * 24 * 3600 * 1000L);

		// 往前推一个月
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1);
		Date updateDate2 = calendar.getTime();
		System.out.println("往前推1个月的时间" + sdf.format(updateDate2));
		// 往后推13个月
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 13);
		Date updateDate3 = calendar.getTime();
		System.out.println("往后推13个月的时间=" + sdf.format(updateDate3));
		// 往后推一天
		calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) + 1);
		Date updateDate4 = calendar.getTime();
		System.out.println("往后推1天的时间=" + sdf.format(updateDate4));

运行结果：
1537845735819往前推1天的时间=2018-09-25 11:22:15
1537845735往前推1天的时间=2018-09-25 11:22:15
false
往前推1个月的时间2018-08-25 11:22:15
往后推13个月的时间=2019-09-25 11:22:15
往后推1天的时间=2019-09-26 11:22:15

(1)昨天八点到现在：

    public static void main(String[] args) {  
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY,8);
		calendar.set(Calendar.MINUTE,0);
		calendar.set(Calendar.SECOND,0);
		calendar.set(Calendar.MILLISECOND,0);
		calendar.add(Calendar.DAY_OF_YEAR,-1);
		Date date = calendar.getTime();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String startTime = sdf.format(date);
		System.out.println("startTime-->"+startTime);
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String endTime = sdf1.format(new Date());
		System.out.println("endTime-->"+endTime);
    }

运行结果：
startTime-->2018-10-09 08:00:00
endTime-->2018-10-10 14:28:04

cal1.add(Calendar.DAY_OF_MONTH,1);  
cal1.add(Calendar.DAY_OF_YEAR,1);  
cal1.add(Calendar.DATE,1);

上面这三个就是单纯的 add 操作，结果都是一样的，因为都是将日期+1，就没有区别说是在月的日期中加1还是年的日期中加1。
但是 Calendar 设置 DAY_OF_MONTH 和 DAY_OF_YEAR 的目的不是用来+1，如果将日期加1，通过 cal1.add(Calendar.DATE,1) 就可以实现。
DAY_OF_MONTH 的主要作用是 cal.get(DAY_OF_MONTH)，用来获得这一天在是这个月的第多少天，Calendar.DAY_OF_YEAR 的主要作用是 cal.get(DAY_OF_YEAR)，用来获得这一天在是这个年的第多少天。同样，还有 DAY_OF_WEEK，用来获得当前日期是一周的第几天。

16. 概率实现：

（可参考：https://www.cnblogs.com/zz-3m23d-begining/p/7767214.html）

public static void main(String[] args) {
    double d = Math.random();//生成一个0~1的随机数
    if(d<=0.5){
        System.out.println("A");//50%概率
    }else if(d<=0.8){
        System.out.println("B");//30%概率
    }else{
        System.out.println("C");//20%概率
    }
}

生成一个 1~10 的随机数：nextInt(10) 方法将生成一个0到9的随机整数，因此我们在其结果上加1来确保生成的随机数是1到10

import java.util.Random;
 
public class RandomNumberExample {
    public static void main(String[] args) {
        Random random = new Random();
        int randomNumber = random.nextInt(10) + 1; // 生成1到10的随机数
        // double randomNumber = random.nextInt(10) + 1;
        System.out.println(randomNumber);
    }
}

17. 正则匹配：

	public static void main(String[] args) {
		String line = "6414636447";
		String pattern = "^\\d+$";
		Pattern p = Pattern.compile(pattern);
		Matcher matcher = p.matcher(line);
		if (matcher.matches()) {
			System.out.println(true);
		}
	}

可参考：正则表达式详解

18. 判断字符串是否为空的四种方法：

来自：java 判断字符串是否为空的四种方法

# 方法一: 最多人使用的一个方法, 直观, 方便, 但效率很低:
if(s == null || s.equals(""));

# 方法二: 比较字符串长度, 效率高, 是我知道的最好一个方法:
if(s == null || s.length() == 0);

# 方法三: Java SE 6.0 才开始提供的方法, 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用方法二.
if(s == null || s.isEmpty());

# 方法四: 这是一种比较直观,简便的方法,而且效率也非常的高,与方法二、三的效率差不多:
if (s == null || s == "");

# 判断对象：
memberEntity == null || "".equals(memberEntity.get属性)

# 判断list
list != null && !list.isEmpty()

注意：s == null 是有必要存在的。如果 String 类型为 null，而去进行 equals(String) 或 length() 等操作会抛出 java.lang.NullPointerException。并且 s==null 的顺序必须出现在前面，不然同样会抛出 java.lang.NullPointerException。

19. 退出程序的方法：

来自：JAVA 中退出程序的方法，退出 Java 中的方法

（1）使用：System.exit() 方法
System.exit()：System.exit(int status) 方法可用于退出 Java 虚拟机。通常将非零值作为参数传递给该方法，表示程序异常终止。调用 System.exit(0) 表示正常退出程序。

System.exit(0);

其中的 System.exit(0);是一种在执行时终止 Java 虚拟机 (JVM) 的方法，这也会导致当前正在运行的程序终止。它需要一个参数，即状态。如果状态为 0，则表示终止成功，而非零状态表示终止不成功。

（2）使用：return 关键字
在主方法或其他任何方法中使用 return 语句可以退出当前方法，并返回到调用方。如果在主方法中使用 return 语句，将会结束整个程序的执行。

return;

可以运用在程序退出上也可以运用在函数值返回上。

（3）使用异常
抛出一个未被捕获的异常也可以导致程序退出。

public class ExceptionExample {
    public static void main(String[] args) {
        System.out.println("Before exception");
        throw new RuntimeException("Exception occurred"); // 抛出异常，退出程序
        System.out.println("没有执行！！！"); // 不会执行到这里
    }
}

20. 同一数据类型多个值初始化时可以简写：

double a = 0;
double b = 0;
double c = 0;
double d = 0;
double e = 0;
double f = 0;
// 优化后：
double a = 0, b = 0, c = 0;
double d = 0, e = 0, f = 0;

21. 去掉数字前面的零：

实现方法一：

String number = "0001234";
int result = Integer.parseInt(tempStr);
System.out.println(result ); // 输出：1234

实现方法二：

可以使用正则表达式来去掉数字前面的零。首先将数字转换为字符串，然后使用正则表达式替换掉前面的零。具体代码如下：

String number = "0001234";
String result = number.replaceFirst("^0+", "");
System.out.println(result); // 输出：1234

实现方法三：

可以使用 java 内置的字符串处理方法来去掉数字前面的零。使用 trim() 方法去掉字符串两端的空格，然后使用 replaceAll() 方法将前面的零替换为空字符串。具体代码如下：

String number = "0001234";
String result = number.trim().replaceAll("^0+", "");
System.out.println(result); // 输出：1234

实现方法四：使用 NumberFormat 类

import java.text.NumberFormat;
import java.util.Locale;

String str = "000123";
NumberFormat formatter = NumberFormat.getInstance(Locale.ENGLISH);
Number number = formatter.parse(str);
System.out.println(number);  // 输出: 123

实现方法五：转换为 BigInteger 或 BigDecimal

String str = "000123";
BigInteger bigInt = new BigInteger(str);
System.out.println(bigInt);  // 输出: 123

实现方法六：自定义方法

可以使用循环遍历字符串的方式来去掉数字前面的零。从字符串的第一个字符开始判断，如果是零则舍弃，直到遇到第一个非零字符为止。如果数字是以字符串形式给出的，并且你知道它是一个整数，你可以简单地遍历字符串并删除前面的零。但这种方法在处理大数字或浮点数时可能会遇到问题。具体代码如下：

String number = "0001234";
int startIndex = 0;
while (startIndex < number.length() && number.charAt(startIndex) == '0') {
    startIndex++;
}
String result = number.substring(startIndex);
System.out.println(result); // 输出：1234

实现方法七：使用 java.text.DecimalFormat

DecimalFormat df = new DecimalFormat("#");
System.out.println(df.format(0123456.78));  // 输出: 123456，前面没有零。

22. 四舍五入保留小数点后两位：

方法一：使用 DecimalFormat 类。缺点：无法四舍五入，相当于是截取

import java.text.DecimalFormat;
 
public class Main {
    public static void main(String[] args) {
        double number = 3.1415926;
        
        DecimalFormat df = new DecimalFormat("#.##"); // 保留2位,不足保留原位数，不补零
        // DecimalFormat df = new DecimalFormat("0.00"); // 保留2位,不足补零
        String result = df.format(number);
        
        System.out.println(result);
    }
}
// 输出结果：3.14

方法二：使用BigDecimal类。ROUND_HALF_UP 是我们常用的四舍五入，即舍入部分大于等于0.5时进位，否则丢弃舍入部分。还有其他类似参考可以自由定义舍取规则。

import java.math.BigDecimal;
 
public class Main {
    public static void main(String[] args) {
        double number = 3.1415926;
        
        BigDecimal bd = new BigDecimal(number);
        double result = bd.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        
        System.out.println(result);
    }
}
// 输出结果：3.14

方法三：使用Math.round函数

public class Main {
    public static void main(String[] args) {
        double number = 3.1415926;
      
        double result = Math.round(number * 100) / 100.0;
      
        System.out.println(result);
    }
}
// 输出结果：3.14

小强签名设计

关注

7
点赞
踩
48

收藏

觉得还不错? 一键收藏
打赏
3
评论
Java代码常用功能实现总结（一）

目录1.获取当前系统时间：2.获取当前时间戳：3.获取主机名和IP4.new String用法：5.ByteBuffer和String的互相转换：6.int和string相互转换：7.把多个json放到list中：8.List集合去除重复数据：9.判断数组中是否包含某个元素10.遍历Map的四种方法11.除去字符串(String)中的换行字符(\r \n...
复制链接

扫一扫