【Java基础】第十五课:API--String

特点:字符串是常量,它们不能创建后被改变。原因是在源码的定义中是这样的:

public final class String{
    /** The value is used for character storage. */
    private final char value[];
}

从这里可以看出:String这个类被定义成了final类,存储字符串的数组也被定义成了常量。所以才造成了它的这个特点。

构造方法:构造方法有两种,一种是:String(char[] value)   一种是String(String original)  ,这种构造我们经常用,它的简写是 String s="aaa"

常用方法:String的方法非常多,下面是它常用的:

验证:

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;
public class Test2_String {
	public static void main(String[] args) {
		//创建对象--触发构造函数  
//		String(char[] value) 
		char[] value= {'a','b','c','d'};
		String s=new String(value);
//		String(String original) 
		String s2="xiaoming";
		//方法测试
		System.out.println(s2.charAt(2));
		System.out.println(s2.concat("jack"));
		System.out.println(s2.endsWith("happy"));
		System.out.println(s2.equals("abcdef"));
		System.out.println(s2.indexOf("a"));
		System.out.println(s2.lastIndexOf("i"));
		System.out.println(s2.isEmpty());
		System.out.println(s2.length());
		System.out.println(s2.replace("a", "b"));
		System.out.println(s2.startsWith("abc"));
		System.out.println(s2.substring(3));
		System.out.println(s2.substring(3,6));
		System.out.println(s2.toUpperCase());
		System.out.println(s2.trim());
		byte[] bs=s2.getBytes();//把字符串中的数据存入byte里,
		System.out.println(Arrays.toString(bs));
		s2="0s0d0fg0g";
		String[] ss=s2.split("0");
		System.out.println(Arrays.toString(ss));
		System.out.println(String.valueOf(123)+456);
//		接收键盘输入的每个字符串然后打印出来----遍历字符串
		Scanner scan=new Scanner(System.in);
		String str=scan.nextLine();
		for (int i = 0; i < str.length(); i++) {
			System.out.println(str.charAt(i));
		}
	}
}

结果:

工具类:StringBuffer  和StringBulider,这两个类是用来做字符串的拼接用的,由于通过“+”来进行拼接需要的时间很长,于是这里用到了StringBuffer 和StringBulider,他们的用法相同。调用它们的append方法,可以加快效率。下面进行测验:

测试:



public class Test3_StringBuilder {
	public static void main(String[] args) {
		method();
//		method2();
	}
	private static void method2() {
		// TODO Auto-generated method stub
		String s="abcdefghijklmnopqrstuvwxyz";
		String aa="";
		long start=System.currentTimeMillis();
		for (int i = 0; i <10000; i++) {
			StringBuffer sb=new StringBuffer();
			sb.append(s);
		}
		long end=System.currentTimeMillis();
		System.out.println(end-start);
	}
	private static void method() {
		// TODO Auto-generated method stub
		//1:把指定字符串拼接一千次,并打印结果
		String s="abcdefghijklmnopqrstuvwxyz";
		String aa="";
		long start=System.currentTimeMillis();
		for (int i = 0; i <10000; i++) {
			aa=aa+s;
		}
		long end=System.currentTimeMillis();
		System.out.println(end-start);//168497
	}
}

结果:

如果用method2,那么结果是4.

可以看出这个工具类的效果十分强大。

### 回答1: 可以使用Java中的日期时间API(如LocalDateTime)和集合操作(如Stream API)来实现将重叠的时间段合并的操作。下面是一个可能的实现: ```java import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { List<String> timeStrings = List.of("10:00-20:00", "11:00-15:00", "17:00-18:00"); List<LocalDateTime[]> timeRanges = timeStrings.stream() .map(Main::parseTimeString) .sorted(Comparator.comparing(range -> range[0])) .collect(Collectors.toList()); List<LocalDateTime[]> mergedTimeRanges = new ArrayList<>(); LocalDateTime[] currentRange = timeRanges.get(0); for (int i = 1; i < timeRanges.size(); i++) { LocalDateTime[] nextRange = timeRanges.get(i); if (currentRange[1].isAfter(nextRange[0])) { currentRange[1] = currentRange[1].isAfter(nextRange[1]) ? currentRange[1] : nextRange[1]; } else { mergedTimeRanges.add(currentRange); currentRange = nextRange; } } mergedTimeRanges.add(currentRange); List<String> mergedTimeStrings = mergedTimeRanges.stream() .map(Main::formatTimeRange) .collect(Collectors.toList()); System.out.println(mergedTimeStrings); } private static LocalDateTime[] parseTimeString(String timeString) { DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm"); String[] parts = timeString.split("-"); LocalDateTime start = LocalDateTime.parse(parts[0], formatter); LocalDateTime end = LocalDateTime.parse(parts[1], formatter); return new LocalDateTime[]{start, end}; } private static String formatTimeRange(LocalDateTime[] timeRange) { DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm"); return timeRange[0].format(formatter) + "-" + timeRange[1].format(formatter); } } ``` 这个实现首先将输入的时间字符串解析为起始和结束的LocalDateTime数组,并按照起始时间进行排序。然后,它使用一个循环来遍历时间范围数组,并根据它们是否重叠来将它们合并。最后,它将合并后的时间范围转换回字符串表示形式,并将其作为输出返回。 ### 回答2: 要将重叠的时间段合并并返回一个新的集合或数组,可以按照以下步骤进行: 1. 创建一个表示时间段的自定义类,包含开始时间和结束时间属性。 2. 将输入的字符串时间段转换为时间段对象,并存储在一个集合中。 3. 创建一个新的集合用于存储合并后的时间段结果。 4. 遍历时间段集合,将第一个时间段添加到结果集合中。 5. 从第二个时间段开始,将其与结果集合中的最后一个时间段进行比较,如果两者有重叠部分,则合并两个时间段的时间范围,并更新结果集合中最后一个时间段。 6. 如果两者没有重叠部分,则直接将当前时间段添加到结果集合中。 7. 重复步骤5和6,直到遍历完所有时间段。 8. 返回结果集合。 以下是一个示例代码实现: ``` import java.util.ArrayList; import java.util.List; class TimeInterval { int start; int end; public TimeInterval(int start, int end) { this.start = start; this.end = end; } } public class Main { public static void main(String[] args) { List<String> timeStrings = new ArrayList<>(); timeStrings.add("10:00-20:00"); timeStrings.add("11:00-15:00"); timeStrings.add("17:00-18:00"); List<TimeInterval> timeIntervals = new ArrayList<>(); for (String timeString : timeStrings) { String[] parts = timeString.split("-"); int start = Integer.parseInt(parts[0].split(":")[0]); int end = Integer.parseInt(parts[1].split(":")[0]); timeIntervals.add(new TimeInterval(start, end)); } List<TimeInterval> mergedIntervals = new ArrayList<>(); mergedIntervals.add(timeIntervals.get(0)); for (int i = 1; i < timeIntervals.size(); i++) { TimeInterval current = timeIntervals.get(i); TimeInterval lastMerged = mergedIntervals.get(mergedIntervals.size() - 1); if (current.start <= lastMerged.end) { lastMerged.end = Math.max(lastMerged.end, current.end); } else { mergedIntervals.add(current); } } for (TimeInterval interval : mergedIntervals) { System.out.println(interval.start + ":00-" + interval.end + ":00"); } } } ``` 运行以上代码将输出合并后的时间段: ``` 10:00-20:00 ``` ### 回答3: 可以使用Java代码来实现将重叠的时间段合并,并返回一个新的集合或数组。具体的实现步骤如下: 1. 定义一个类TimeSlot,表示时间段,包含开始时间和结束时间的属性。 例如: class TimeSlot{ int start; int end; } 2. 创建一个空的List集合,用于存储所有时间段的对象。 3. 使用循环遍历输入的时间段字符串集合,将每个时间段的开始时间和结束时间分别转化为整型,并创建一个TimeSlot对象将时间段存储在其中,再将该对象添加到List集合中。 4. 根据时间段的开始时间进行升序排序,可以使用Comparator接口的实现类来实现比较并排序。 5. 创建一个新的List集合,用于存储合并后的时间段。 6. 使用循环遍历已排序的时间段List集合,依次比较相邻的两个时间段。 a. 如果当前时间段和下一个时间段的结束时间有重叠,将当前时间段的结束时间更新为下一个时间段的结束时间。 b. 如果没有重叠,将当前时间段添加到新的List集合中。 7. 返回新的List集合,即合并后的时间段。 以下是一个示例代码: import java.util.*; public class TimeSlotMerge { public static void main(String[] args) { List<String> timeSlots = Arrays.asList("10:00-20:00", "11:00-15:00", "17:00-18:00"); List<TimeSlot> slots = new ArrayList<>(); for (String timeSlot : timeSlots) { TimeSlot slot = new TimeSlot(); String[] times = timeSlot.split("-"); slot.start = Integer.parseInt(times[0].split(":")[0]); slot.end = Integer.parseInt(times[1].split(":")[0]); slots.add(slot); } Collections.sort(slots, new Comparator<TimeSlot>() { public int compare(TimeSlot s1, TimeSlot s2) { return s1.start - s2.start; } }); List<TimeSlot> mergedSlots = new ArrayList<>(); int start = slots.get(0).start; int end = slots.get(0).end; for (int i = 1; i < slots.size(); i++) { if (slots.get(i).start <= end) { end = Math.max(end, slots.get(i).end); } else { mergedSlots.add(new TimeSlot(start, end)); start = slots.get(i).start; end = slots.get(i).end; } } mergedSlots.add(new TimeSlot(start, end)); for (TimeSlot slot : mergedSlots) { System.out.println(slot.start + ":00-" + slot.end + ":00"); } } } 希望对你有所帮助!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值