2018-05-30 第二十四天-低调大师

2018-05-30 第二十四天

2018-05-29 545

一、String

public final class String extends Object implements Serializable, Comparable, CharSequence

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。大小写映射基于 Character 类指定的 Unicode 标准版。

例1：

import java.util.Arrays;

public class TestString {

public static void main(String[] args) {

byte[] bs = {65,66,67,68,69};

//通过字节数组创建字符串对象

String str = new String(bs);

//将字符穿对象转换为字节数组

System.out.println(Arrays.toString(str.getBytes()));//{65,66,67,68,69}

System.out.println(str);//ABCDE

//得到字节数组指定区间的字符串对象

System.out.println(new String(bs,1,3));//BCD

//创建一个字符串对象，根据指定的值

str = new String("0123456789");

//0序的

System.out.println(str.charAt(3));//3

//字符串连接原字符串不变

System.out.println(str.concat("asd"));//0123456789asd

//是否包含某个子字符串

System.out.println(str.contains("0234"));//false

//某个字符串是否以什么结尾

System.out.println(str.endsWith(""));//true

//字符串格式化，

System.out.println(String.format("%s攻击了%s，%s掉了%d滴血", "阿基里斯","赫克托","赫克托",100));//100是自动装箱

//从前往后找

System.out.println(str.indexOf(52));//4

System.out.println(str.indexOf("345"));//3

System.out.println(str.indexOf("345", 6));//-1

//求长度

System.out.println(str.length());//10

//生成一个新的字符串

System.out.println(str.replace("2", "__"));

//切割字符串

str = "123_5435_1232_545_343_DSF";

System.out.println(Arrays.toString(str.split("_")));

System.out.println(str.substring(8));//_1232_545_343_DSF

System.out.println(str.substring(1, 2));//2

//去掉前后的空白字符

str = " uiu ou ou ou ";

System.out.println(str.trim());

System.out.println();

System.out.println(str);

}

例2：

//* 1：在工具类中定义工具方法，对指定的字符串，求出该字符串中，出现指定字符的个数。

//* 2：自定义方法，实现产生一个随机字符串，长度为20，每一个字符要求全部随机产生，然后统计该字符串中的大写字符和小写字符的个数并以数组形式返回统计的个数

//* 3：自定义方法，针对指定的字符串，返回该字符串的逆序形式。

import java.util.Arrays;

import com.bjsxt.util.MyUtil;

public class TestString1 {

public static void main(String[] args) {

System.out.println(getCharCount("3278239782981", '8'));

String str = getRandomStr(20);

System.out.println(str);

System.out.println(Arrays.toString(getLowerAndUpperCharCount(str)));

}

// 在工具类中定义工具方法，对指定的字符串，求出该字符串中，出现指定字符的个数。

public static int getCharCount(String str , char key){

if(str == null)

return -1;

if(str.isEmpty())

return 0;

int counter = 0;

int len = str.length();

for (int i = 0; i < len; i++) {

//取出每个字符进行比对

char c = str.charAt(i);

if(key == c)

counter ++;

}

return counter;

}

//自定义方法，实现产生一个随机字符串，长度为20，每一个字符要求全部随机产生，然后统计该字符串中的大写字符和小写字符的个数并以数组形式返回统计的个数

//随机产生一个指定长度的字符串

public static String getRandomStr(int length){

String str = "";

for(int i=0;i

//得到随机区间的值

int ranNumber = MyUtil.getRandomNumber('A', 'Z'+1);

//随机大小写的字符

char ranChar = (char)(Math.random() > 0.5 ? ranNumber : ranNumber + 32);

str = str.concat(Character.toString(ranChar));

}

return str;

}

//针对指定的字符串，统计字符串中大小写的个数，以数组形式返回。

public static int[] getLowerAndUpperCharCount(String str){

if(str == null)

return null;

if(str.isEmpty())

return null;

int[] count = new int[2];

//统计

int len = str.length();

for (int i = 0; i < len; i++) {

char c = str.charAt(i);

if(Character.isUpperCase(c)){

count[0]++;

}else if(Character.isLowerCase(c)){

count[1]++;

}

return count;

}

// 自定义方法，针对指定的字符串，返回该字符串的逆序形式。

public static String reverse(String str){

//逆序取出来，连接

if(str == null)

return null;

if(str.isEmpty())

return "";

String newStr = "";

int len = str.length();

for (int i = len-1; i >= 0; i--) {

char c = str.charAt(i);

newStr += c;

}

return newStr;

}

二、原码分析

1：字符串类型底层使用 char[] 实现。是一个final 修饰的数组。

String 类没有提供对外的任何修改原有字符串的方法。

结论：字符串对象一旦创建，就不能更改。所有的看似对字符串的修改，都不是在原有的字符串对象上的修改，而是会生成一个新的字符串对象。

这样的特点导致了，在程序中使用字符串对象，会在内存中生成大量的字符串对象的碎片。造成对内存的浪费。

java 对String 进行了特殊的处理，来尽量的避免这样的问题。

三、String扣留intern 机制

java 对字符串提供了一种字符串扣留 intern 机制。

java 对字符串常量提供了一个字符串常量池的内存空间。在方法区中。扣留机制的基础。

字符串常量池由String 类自己维护。

在编译期一个类有哪些字符串常量就确定了。在类加载的时候，就会把当前类的所有的字符串常量加载到字符串常量池中。

1：String str = "abc";

在java 语句中，如果存在了一个字符串常量，那么 String 类的扣留机制会自动的判断该常量是否存在于常量池中

如果存在，那么直接将常量池中的字符串对象的引用返回，不会创建新的字符串对象。

如果在常量池中不存在该常量，那么就将该常量添加到常量池中，并返回常量池字符串的地址。

这样的赋值方式会产生[0-1]个字符串对象。

2:String str = new String("123");

首先对字符串常量"123"，进行扣留机制的判断。可能产生[0-1]个对象。

new 出来的String 对象在堆区中被创建。新的String 对象中的成员 value 指向常量池中的字符串地址。

这样的创建对象的方式会产生[1-2]个对象。

要求：使用第一种创建字符串对象的方式。

public class TestInternString {

public static void main(String[] args) {

//产生了一个字符串对象 a ，在常量池中

String a = "a";

//产生了一个字符串对象 b ，在常量池中

String b = "b";

//产生了一个字符串对象 ab ，在常量池中

String s1 = "ab";

//编译之后和 a和b 合并，没有产生字符串对象，直接指向方法区 "ab";

String s2 = "a"+"b";

//会产生一个新的对象，指向堆的。涉及到字符串变量的+连接的实现。

String s3 = a + b;

//在堆中产生一个新的对象

String s4 = new String("ab");

//如果"ab" 字符串已经存在于常量池中，那么直接返回常量池的地址。

//如果“ab” 不存在于常量池中。那么就将"ab" 在运行期动态的添加到常量池，并返回常量池字符串的地址。

//intern 将当前字符串对象动态的添加到常量池中，并返回在常量池中的地址。

String s5 = new String(a+b).intern();

System.out.println(s1 == s2);//true

System.out.println(s1 == s3);//false

System.out.println(s1 == s4);//false

System.out.println(s1 == s5);//true

}

四、StringBuffer和StringBuilder

StringBuffer：

可以修改的字符串对象。可以认为是一个增强版的String。

在原有的String的功能上面（有些功能没有），增加了对字符串序列的增删改。

底层使用char[] 数组实现。

StringBuilder是在某些情况下的替代StringBuffer 类的一个类。和StringBuffer类的用法完全一样。API 兼容。

StringBuffer 是线程安全的。

效率相对较低。

StringBuilder 是线程非安全的。

效率更高。

总结：在线程安全的情况下使用StringBuilder。

例：

/**

* 对于指定的一个字符串，将该字符串的统计表示形式[asdasdasd---a(3)s(3)d(3)]保存到一个StringBuffer中，并最后打印输出。

* 思路：逐个遍历字符串中的每个字符，将统计的结果放到一个StringBuffer中，如果被遍历的字符还没有出现在

* StringBuffer 中，则在StringBuffer中尾部添加该字符并在该字符后增加 (1) ，如果已经存在与StringBuffer

* 则将该字符后的小括号中的字符串取出，转换为int，然后+1后，再插入原位置。最后返回StringBuffer的字符串形式。

*/

public static String countTypeChar(String str){

if(str == null)

return null;

if(str.isEmpty())

return "";

int len = str.length();

StringBuffer sb = new StringBuffer();

for (int i = 0; i < len; i++) {

char c = str.charAt(i);

//得到c 在 sb 中的位置

int index = sb.indexOf(Character.toString(c));

//c 已经存在sb 中了。那么将原有的数量获得，并删除，加1 之后插入回去。

if(index >=0 ){

//先获得sb 中c 的数量

//数量的起始索引,和结束索引

int start = index + 2;//当前字符的右边的第二个符号

int end = sb.indexOf(")", start);

//获得当前字符的在sb 中数量的值

int count = Integer.parseInt(sb.substring(start, end));

//删除数量字符串

sb.delete(start, end);

//原有数量+1 插入回去

count ++;

sb.insert(start, Integer.toString(count));

}else{//不在sb 中尾部添加即可

sb.append(c+"(1)");

}

return sb.toString();

}

五、String类的 + 连接的实现

/**

* String 类的+ 连接实现

*

*/

public class TestStringBuffer1 {

public static void main(String[] args) {

String a = "a";

//直接指向常量池

String b = "a" + "b";

//变量相加或者是变量和常量相加底层使用StringBuilder 实现。

//在StringBuilder 没有出来之前，使用StringBuffer 实现 + 连接。

String c = a + b + "a";

String str = new StringBuilder(a).append(b).append("a").toString();

}

六、字符串连接性能测试

public class TestStringConcat {

public static void main(String[] args) {

long time = System.currentTimeMillis();

for(int i=0;i<100000;i++){

concat6("rewrewrewfewrewfdwefewfrewfew", "32lkfjklwejrl2o3kdlemfrl243kj", "fjoweurolenmflkdnmvklsdnlkfew",

"fu98u798rjhoifdjiefldsfjdskljfvcd", "9123ljkrlemwfklmwe,.fm c,.dmv", "23oirjelkfmnkdslnmvkldsnmvdsklmnfds");

}

long cost = System.currentTimeMillis()-time;

System.out.println("cost = " + cost);

}

//210ms 会创建6个StringBuilder 对象

static String concat1(String s1,String s2,String s3,String s4,String s5,String s6){

String str = "";

str += s1;

str += s2;

str += s3;

str += s4;

str += s5;

str += s6;

return str;

}

//95 线程安全的，创建了一个StringBuffer 对象，存在多次扩容的行为

static String concat2(String s1,String s2,String s3,String s4,String s5,String s6){

StringBuffer sb = new StringBuffer();

sb.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);

return sb.toString();

}

//85 线程非安全的，创建了一个StringBuilder 对象，存在多次扩容的行为

static String concat3(String s1,String s2,String s3,String s4,String s5,String s6){

StringBuilder sb = new StringBuilder();

sb.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);

return sb.toString();

}

//62 创建了一个StringBuilder对象，存在多次扩容

static String concat4(String s1,String s2,String s3,String s4,String s5,String s6){

return s1 + s2 + s3 + s4 + s5 + s6;

}

//67 创建一个StringBuffer 对象，不存在扩容行为

static String concat5(String s1,String s2,String s3,String s4,String s5,String s6){

StringBuffer sb = new StringBuffer(s1.length()+s2.length() + s3.length() + s4.length() + s5.length() +s6.length());

sb.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);

return sb.toString();

}

//48 创建一个StringBuilder 对象，不存在扩容行为

static String concat6(String s1,String s2,String s3,String s4,String s5,String s6){

StringBuilder sb = new StringBuilder(s1.length()+s2.length() + s3.length() + s4.length() + s5.length() +s6.length());

sb.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);

return sb.toString();

}

七、File

一个File对象既可以表示一个文件，也可以表示一个目录。

提供了对文件对象和目录对象的各种操作的方法。

对文件的操作：

创建文件

删除文件

修改文件的属性，不能修改文件的内容。

判断是文件还是目录

得到目录下是所有的文件对象。

判断文件或者目录是否存在

获得文件的绝对路径。

获得文件的名字

重命名文件

......

绝对路径：相对于盘符的路径。

相对路径：相当于当前工程根目录。

例：

import java.io.File;

import java.io.IOException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class TestFile {

// 在相对路径中创建1.txt 文件工程目录下

// 在c盘的根目录下创建文件2.txt，并修改其修改的时间 1970-05-20 13:14:20。

// 在c盘的根目录下创建文件c:/7/7/2.txt

// 将指定的目录下的，指定的后缀的文件全部删除

// 使用递归将某个目录下的所有的文件以及子目录中的文件文件的个数的统计。

// 使用递归实现，将指定的目录以及其子目录全部删除。

public static void main(String[] args) {

// 从当前系统动态获得的路径分隔符和目录分隔符

System.out.println(File.pathSeparator);// ;

System.out.println(File.separator);// \

// deleteFilesBySuffix("c:\\class\\501", "class");

test2();

}

// 在res 的相对目录中，创建或者删除指定的文件

static void test1() {

File file = new File("." + File.separator + "res" + File.separator

+ "1.txt");

if (file.exists()) {// 文件存在，删除，

file.delete();

} else {// 不存在，创建新的

try {

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

// 在c盘的根目录下创建文件2.txt，并修改其修改的时间 1970-05-20 13:14:20。

static void test2() {

File file = new File("F:\\2.txt");

if (!file.exists()) {

try {

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

// 修改 time 要求是距离 1970 年1月1日的毫秒的时间差

try {

file.setLastModified(Long

.parseLong(dateToStamp("1970-05-20 13:14:20")));

} catch (NumberFormatException e) {

e.printStackTrace();

} catch (ParseException e) {

e.printStackTrace();

}

// file.lastModified()

}

// 在c盘的根目录下创建文件c:/7/7/2.txt

static void test3() {

File file = new File("c:\\88\\88");

// 先创建目录

// file.mkdir() 只能创建一层

file.mkdirs();

// 再创建文件

File file2 = new File(file, "2.txt");

if (!file2.exists()) {

try {

file2.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

/**

*删除指定目录下的指定的后缀的文件

*

* @param path

* @param suffix

*/

static void deleteFilesBySuffix(String path, String suffix) {

File file = new File(path);

// 得到当前目录下的所有的文件

File[] files = file.listFiles();

// 遍历所有的文件，如果文件的名字以suffix 结尾就删除

for (File file2 : files) {

// 获得文件的名字

String name = file2.getName();

if (name.endsWith(suffix)) {

file2.delete();

}

/*

* 将时间转换为时间戳

· public static String dateToStamp(String s) throws ParseException {

String res;

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(

"yyyy-MM-dd HH:mm:ss");

Date date = simpleDateFormat.parse(s);

long ts = date.getTime();

res = String.valueOf(ts);

return res;

}

微信关注我们

原文链接：https://yq.aliyun.com/articles/598417

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Java 学习（03）--运算符/循环小结

Java 学习（03） Java 运算符 1、算术运算符： 1.+,-,*,/,%,++,- 2.+的用法 a: 加法 b: 正号 c: 字符串连接符 3./ 和%的区别数据做除法操作的时候， / 取得是商， %取得是余数 4.++和-- 的用法 a: 他们的作用是自增或者自减 b: 使用 ** 单独使用放在操作数据的前面和后面效果一样。 a++或者++a 效果一样。 5. 参与操作使用放在操作数的前面：先自增或者自减，再参与操作 int a = 10; int b = ++a; 放在操作数的后面：先参与操作，再自增或者自减 int a = 10; int b = a++; 2、赋值运算符 1.=,+=,-=,*=,/=,%= 2.=叫做赋值运算符，也是最基本的赋值运算符 int x = 10; 把 10 赋值给 int 类型的变量 x 3.扩展的赋值运算符的特点隐含了自动强制转换。面试题：请问下面的代码哪个有问题 ? short s = 1; s = s + 1; // 错误 short s = 1; s += 1; // 正确答： s += 1; 不是等价于 ...

2018-05-30

562

原文地址：http://412887952-qq-com.iteye.com/blog/2348445 我们通过getBean来获得对象,但这些对象都是事先定义好的,我们有时候要在程序中动态的加入对象.因为如果采用配置文件或者注解，我们要加入对象的话,还要重启服务,如果我们想要避免这一情况就得采用动态处理bean,包括：动态注入,动态删除。本节大纲：（1）动态注入bean思路；（2）动态注入实现代码；（3）多次注入同一个bean的情况；（4）动态删除；接下来我们看下具体的内容：（1）动态注入bean思路；在具体进行代码实现的时候，我们要知道，Spring管理bean的对象是BeanFactory，具体的是DefaultListableBeanFactory，在这个类当中有一个注入bean的方法：registerBeanDefinition，在调用registerBeanDefinition方法时，需要BeanDefinition参数，那么这个参数怎么获取呢？Spring提供了BeanDefinitionBuilder可以构建一个BeanDefinition...

2018-05-30

729

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。