日更，教你如何一步步成为java软件工程师——常用类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了日更，教你如何一步步成为java软件工程师——常用类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14034字，纯文字阅读大概需要21分钟。

内容图文

常用类

使用：在API中查询其具体使用方式

• String
• StringBuilder:可变长字符串,线程不安全的,效率较高
• StringBuffer:可变长字符串,线程安全的,效率较低

public class TestString02 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String str="shsxtgood";
		String str2="Shsxtgood";
		System.out.println(str);
		//char charAt(int index) 返回指定索引处的char值。  ***
		System.out.println("charAt():"+str.charAt(2));
		//int indexof(String str)返回指定子字符串在此字符串中第一次出现处的索引。***
		System.out.println("indexOf():"+str.indexOf("h"));
		//int indexOf(String str, int fromIndex)
		System.out.println("indexOf(),指定起始索引:"+str.indexOf("o",6));
		//int lastIndexOf(String str)   返回指定子字符串在此字符串中最右边出现处的索引。
		System.out.println("lastIndexOf():"+str.lastIndexOf("o"));
		//int codePointAt(int index) 返回指定索引处的字符（Unicode 代码点）.
		System.out.println("charAt():"+str.codePointAt(2));
		// int compareTo(String anotherString)  按字典顺序比较两个字符串。 
		//相同返回0,不同 使用当前字符串与参数字符串同一个位置的字符进行减法
		System.out.println("compareTo():"+str2.compareTo(str));
		//int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
		System.out.println("compareToIgnoreCase()"+str.compareToIgnoreCase(str2));
		//String concat(String str) 将指定字符串连接到此字符串的结尾。   返回新串
		System.out.println("concat()"+str.concat(str2));
		//boolean contains(CharSequence s)  当且仅当此字符串包含指定的 char 值序列时，返回 true。 
		System.out.println("contains()"+str.contains("shsxt"));
		//static String copyValueOf(char[] data)    字符数组转为字符串
		System.out.println("copyValueOf():"+str.copyValueOf(new char[]{'s'}));
		//static String copyValueOf(char[] data, int offset, int count) 
		//boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 
		//boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
		System.out.println("endsWith()"+str.endsWith("d"));
		
		/*
		 * byte[] getBytes() ***
		 * 			使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中
		 * byte[] getBytes(Charset charset)
		 * 
		 */
		byte[] arr="你好".getBytes();   //UTF-8
		byte[] arr2="你好".getBytes("gbk"); //gbk
		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));
		//void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)将字符从此字符串复制到目标字符数组。 
		char[] charArr=new char[6];
		"你好哈哈哈".getChars(1, 4, charArr, 3);
		//length()   *****
		System.out.println(str.length());
		//String replace(char oldChar, char newChar)  新串替换老串   ***
		System.out.println("replace()"+str.replace("s","S"));
		
		//String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。     ****
				String str3="name==zhangsan";
				String[] s=str3.split("==");
				System.out.println(Arrays.toString(s));
		
		/*
		 * String substring(int beginIndex)     *****
		          返回一个新的字符串，它是此字符串的一个子字符串。 
		   String substring(int beginIndex, int endIndex)   endIndex不包含
		          返回一个新字符串，它是此字符串的一个子字符串。 
		 */
		System.out.println("substring()"+str.substring(3)); 
		System.out.println("substring()"+str.substring(3,6));
		
		//char[] toCharArray() 将此字符串转换为一个新的字符数组。  ***
		char[] ch=str.toCharArray();
		System.out.println(Arrays.toString(ch));
		
		//String toLowerCase()   转小写
		//String toUpperCase()   转大写
		System.out.println("toLowerCase()"+str2.toLowerCase()); 
		System.out.println("toUpperCase()"+str2.toUpperCase()); 
		
		//String trim()返回字符串的副本，忽略前导空白和尾部空白。 
		System.out.println("   yiwei ".trim());
		
		//valueOf() 参数转为字符串
			double d=123.123;
			System.out.println(String.valueOf(d).length());
}
}


public class TestString {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String str = "abc";
		String str4="abc";
		//String(String original)        初始化一个新创建的String对象，使其表示一个与参数相同的字符数列
		//String str2=new String("cde");  2个new ->String,堆中
		String str2=new String("abc");    //1个new->String,堆中
		String str3=new String("abc");
		System.out.println(str);
		System.out.println(str2);
		System.out.println(str2==str);
		System.out.println(str2.equals(str));
		System.out.println(str2==str3);
		System.out.println(str==str4);
		
		//String() 初始化一个新创建的String对象，使其表示一个空字符序列
		String s1=new String();
		
		//String(char[] value)分配一个新的String,使其表示字符数组参数中当前包含的字符序列。
		String s2=new String(new char[]{'s','h','s','x','t'});
		System.out.println(s2);
		
		//String(char[] value,int offset,int count)分配一个新的String,它包含它包含取自字符数组参数一个子数组的字符。
		String s3=new String(new char[]{'s','h','s','x','t'},2,3);
		System.out.println(s3);
		
		//String(byte[] bytes)     通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
		String string="呵呵";
		byte[] arr=string.getBytes();
		System.out.println(Arrays.toString(arr));
		
		String s4=new String(new byte[]{-27, -111, -75, -27, -111, -75});
		System.out.println(s4);	
		//String(byte[] bytes, Charset charset) 
		String s5=new String(new byte[]{-27, -111, -75, -27, -111, -75},"GBK");
		System.out.println(s5);
		
		//String(byte[] bytes, int offset, int length)
		String s6=new String(new byte[]{-27, -111, -75, -27, -111, -75}, 3, 3);
		System.out.println(s6);
	}
}


public class StringBuilder_StringBuffer {
	public static void main(String[] args) {
		//StringBuilder() 构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。
		StringBuilder sb=new StringBuilder();
		System.out.println(sb);
		System.out.println(sb.capacity());  //16
		System.out.println(sb.length());
		//StringBuilder(String str)  构造一个字符串生成器，并初始化为指定的字符串内容。
		StringBuilder sb1=new StringBuilder("abc");
		System.out.println(sb1);
		System.out.println(sb1.capacity()); //16+3
		System.out.println(sb1.length()); //3
		
		//StringBuilder(int capacity) 构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。
		StringBuilder sb2=new StringBuilder(15);
		System.out.println(sb2);
		System.out.println(sb2.capacity());
		System.out.println(sb2.length());
		
		//StringBuilder append(int i)  拼接参数值
		/*
		 * append扩容: 如果原容量放不下进行扩容,  原容量size-->size*2+2,如果扩容后的大小还是放不下,直接以内容的长度进行扩容
		 */
		StringBuilder s=sb.append("12345678901234567");
		sb.append(123.123);
		System.out.println(sb);
		System.out.println(s==sb);
		System.out.println(sb.capacity());  //16
		System.out.println(s.length());  //4
		
		//StringBuilder delete(int start, int end)   不包含end
		 sb.delete(2, 7);
		 System.out.println(sb);
		 
		 //StringBuilder insert(int offset,boolean b)
		 sb.insert(3,true);
		 System.out.println(sb);
		 
		 //StringBuilder reverse()
		 sb.reverse();
		 System.out.println(sb);
	}
}

• 基本数据类型的包装类型

  byte ----- Byte
  short ----- Short
  int ----- Integer
  long ----- Long
  float ----- Float
  double ----- Double
  char ----- Character
  boolean ----- Boolean
  自动装箱：基本数据类型->包装类型
  自动拆箱：包装类型->基本数据类型

public class DataType {
	public static void main(String[] args) {
		int i=100; //int类型
		Integer i2=i; //自动装箱  Integer.valueof(i2)
		int i3=i2; //自动拆箱   i2.intvalue()
		
		haha(1.1,2.2);
		
		int int1=127;
		int int2=127;
		System.out.println(int1==int2);  //true
		//缓冲区对象的表示范围：[-128,127] ==>valueOf()
		Integer int3 =127;
		Integer int4 =127;
		System.out.println(int3==int4);  //true
		
		Integer int5=new Integer(127);
		Integer int6=new Integer(127);
		System.out.println(int5==int6);  //false
		
		Integer int7=128;  //不在缓冲区
		Integer int8=128;
		System.out.println(int7==int8);  //false
		
		//自动 拆箱比较
		System.out.println(int1==int3);  //true  
		System.out.println(int1==int5);  //true  
		System.out.println(int3==int5);  //false
		
		/*1.int 和 Integer(无论是否new)比较:发生自动拆箱，如果值相同就相同
		 *2.如果两个Interger比较，如果有new,就不相同
		 *3.如果都没有new,要看是否在缓冲区对象的范围内
		 */
		
		Double d1 =1.0;
		Double d2 =1.0;
		System.out.println(d1==d2);
		/*
		 * public static Double valueOf(double d){
		 * 		return new Double(d);
		 * }
		 *
		 */
		 
		/*
		 * static int parseInt(String s)
		 * 	将字符串参数作为有符号的十进制整数进行解析
		 * static int parseInt(String s, int radix)   radix是指定使用什么进制解析参数s
		 */
System.out.println(Integer.parseInt("abc123"));//NumberFormatException
		System.out.println(Integer.parseInt("10"));// 10
		System.out.println(Integer.parseInt("10",2));//2   二进制
		
		String str="a"+"b"+"c"+"d";    //"abcd" 1个   编译器会自动优化
		
		str="haha"+new String("abc");  //不会优化
		 
		
	}
	public static double haha(double d1,double d2){
		return d1+d2;
	}
}

• Date日期类

public class DateDemo {
	public static void main(String[] args) {
		Date date = new Date();
		Date date4= new Date();
		System.out.println(date);
		System.out.println(date.getTime()); //获取从1970到当前时间的毫秒数
		Date date2 = new Date(1560153453234L);
		System.out.println(date2);
		
		/*
		 * boolean after(Date when)
		 * 				测试此日期是否再指定日期之后
		 * boolean before(Date when)
		 * 				测试此日期是否再指定日期之后
		 * Object clone()
		 * 				返回此对象的副本
		 * int compareTo(Date anotherDate)
		 * 				比较两个日期的顺序
		 * boolean equals(Object obj)
		 * 				比较两个日期的相等性
		 */
		System.out.println(date.after(date2));
		System.out.println(date.before(date2));
		System.out.println(date.clone());
		System.out.println(date.compareTo(date2));
		System.out.println(date.compareTo(new Date()));
		System.out.println(date.compareTo(date4));
		
		/*
		 * void setTime(long time)
		 * 设置此Date对象，以表示 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。 
		 */
		 date.setTime(1560168941392L);
		// date.setTime(0);
		 System.out.println(date); 			
		 System.out.println(date4.toString());
	}
}

• SimpleDateFormat 日期格式类

以指定格式把字符串与日期对象之间进行转换

y : 年
M : 月
d: 日期
E: 星期
H : 24小时
h : 12小时
m : 分
s : 秒
S : 毫秒

设置转换器格式:SimpleDateFormat对象
SimpleDateFormat() 默认的转换格式
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
SimpleDateFormat(String pattern) 指定转换格式

format(Date) 日期对象准为字符串
parse(String) 字符串准为日期对象

public class SimpleDateFormatDemo {
	public static void main(String[] args) throws ParseException {
		//默认转换器
		SimpleDateFormat simple = new SimpleDateFormat();
		System.out.println(simple.format(new Date()));
		
		//指定格式转换器
		SimpleDateFormat simple2 = new SimpleDateFormat("yyyy/MM/dd E hh:mm:ss:SSS");
		System.out.println(simple2.format(new Date()));
		
		String str="2018年3月12日";
		SimpleDateFormat simple3=new SimpleDateFormat("yyyy年MM月dd日");
		System.out.println(simple3.parse(str));
	}
}

• File

public class FileDemo {
	public static void main(String[] args) {
		//File(String pathname)通过将给定路径字符串转换为抽象路径名来创建一个新File实例。
		File file1=new File("paka,txt");
		File file2=new File("D:\\test.txt");
		File parent=new File("D:/");
		//File(File parent, String child) 
		File file3=new File(parent,"test.txt");
		//File(String parent, String child)
		File file4 =new File("D:/","test.txt");
		
		System.out.println(file1);
		System.out.println(file2);
		System.out.println(file3);
		System.out.println(file2.equals(file3));
		System.out.println(file4);
	}
}
public class Filemethod {
	public static void main(String[] args) throws IOException {
		//boolean canWrite() 
		File file=new File("D:/test.txt");    
		File file2=new File("D:/AAA");    
		File file3=new File("AAA");
		//boolean setReadonly()
		System.out.println("setReadOnly():"+file.setReadOnly());
		System.out.println("canWrite():"+file.canWrite());
		
		//boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
		System.out.println("createNewFile():"+file.createNewFile());
		//boolean delete() 删除此抽象路径名表示的文件或目录。
		System.out.println("delete():"+file.delete());
		//boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
		System.out.println("exists():"+file.exists());
		System.out.println("exists():"+file2.exists());
		/*
		 *   File getAbsoluteFile() 
			          返回此抽象路径名的绝对路径名形式。 
			 String getAbsolutePath() 
			          返回此抽象路径名的绝对路径名字符串。 
		 */
		System.out.println("getAbsoluteFile():"+file.getAbsoluteFile());  //返回值是new File
		System.out.println("getAbsolutePath():"+file.getAbsolutePath());
		System.out.println("createNewFile():"+file.createNewFile());
		/*
		 *  long getFreeSpace() 
 			long getTotalSpace()  
		 */
		//String getName()   返回由此抽象路径名表示的文件或目录的名称。 
		System.out.println("getName():"+file2.getName());
		/*
		 * String getParent() 
		          返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
		   File getParentFile() 
		 */
		System.out.println("getParent():"+file.getParent());
		System.out.println("getParent():"+file.getParentFile());
		//boolean isAbsolute() 测试此抽象路径名是否为绝对路径名
		System.out.println("isAbsolute():"+file.isAbsolute());
		System.out.println("isAbsolute():"+file3.isAbsolute());
		/*
		 * boolean isDirectory() 
		          测试此抽象路径名表示的文件是否是一个目录。 
		   boolean isFile() 
		          测试此抽象路径名表示的文件是否是一个标准文件。 
		 */
		System.out.println("isDirectory():"+file.isDirectory());
		System.out.println("isFile():"+file.isFile());
		/*
		 *  long lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间。 
		 */
		File file4 = new File("D:/wuwu.txt");
		System.out.println("lastModified():"+file4.lastModified());
		System.out.println("lastModified():"+(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss:SSS").format(new Date(file4.lastModified()))));
		
		/*
		 *  String[] list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。 
		 *  File[] listFiles() 
		 */
		System.out.println("list():"+Arrays.toString(file.list()));
		System.out.println("listFiles():"+Arrays.toString(file2.listFiles()));
		/*
		 *  boolean mkdir() 创建此抽象路径名指定的目录。 
 			boolean mkdirs()  
		 */
		File file5=new File("D:/DDD");
		File file6=new File("D:/WUWU/DDD");
		System.out.println("mkdir()"+file5.mkdir());
		System.out.println("mkdir()"+file5.mkdirs());
		
		//boolean renameTo(File Test)
		file5.renameTo(new File("D:/double kill"));
		
	}
}

enum枚举

public class EnumDemo {
	public static void main(String[] args) {
		Week m=Week.Thus;
		//获取属性名称
		System.out.println(m.name());
		//ordinal枚举类中的索引位置
		System.out.println(m.ordinal());
		//获取某个枚举类中的所有成员
		System.out.println(Arrays.toString(m.values()));
		switch (m) {
		case Mon:
			m.setName("星期一");
			break;
		case Tues:
			m.setName("星期二");
			break;
		case Thus:
			m.setName("星期四");
			break;		
		}
		m.info();
	}
}
enum Week{
	Mon,  //public static final Week Mon=mew Week();
	Tues,
	Thus;
	private String name;
	private Week(){
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void info(){
		System.out.println("成员方法"+this.name);
	}
}
class Fu{
	String name;

	@Override
	public String toString() {
		return super.toString();
	}
	
}

内容总结

以上是互联网集市为您收集整理的日更，教你如何一步步成为java软件工程师——常用类全部内容，希望文章能够帮你解决日更，教你如何一步步成为java软件工程师——常用类所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端