本文将带您了解关于javaString的深入理解的新内容，同时我们还将为您解释javastring详解的相关知识，另外，我们还将为您提供关于c#基础系列之System.String的深入理解、Java

本文将带您了解关于java String的深入理解的新内容，同时我们还将为您解释java string详解的相关知识，另外，我们还将为您提供关于c#基础系列之System.String的深入理解、Java String的理解、Java 中 String 类深入理解、java 中Spring task定时任务的深入理解的实用信息。

• java String的深入理解（java string详解）
• c#基础系列之System.String的深入理解
• Java String的理解
• Java 中 String 类深入理解
• java 中Spring task定时任务的深入理解

java String的深入理解（java string详解）

这篇文章主要介绍了java String的深入理解的相关资料,希望通过本文大家能理解String的用法，需要的朋友可以参考下

java String的深入理解

一、Java内存模型 

按照官方的说法：Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。    

JVM主要管理两种类型内存：堆和非堆，堆内存（Heap Memory）是在 Java 虚拟机启动时创建，非堆内存(Non-heap Memory)是在JVM堆之外的内存。

简单来说，非堆包含方法区、JVM内部处理或优化所需的内存（如 JITCompiler，Just-in-time Compiler，即时编译后的代码缓存）、每个类结构（如运行时常数池、字段和方法数据）以及方法和构造方法的代码。     

Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。

堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。     

虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集合，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。

对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在Method Area,而不是堆中。常量池中保存着很多String对象; 并且可以被共享使用，因此它提高了效率 

二、案例解析

public static void main(String[] args) { /** * 情景一：字符串池 * JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; * 并且可以被共享使用，因此它提高了效率。 * 由于String类是final的，它的值一经创建就不可改变。 * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。 */ String s1 = "abc"; //↑ 在字符串池创建了一个对象 String s2 = "abc"; //↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象 System.out.println("s1 == s2 : "+(s1==s2)); //↑ true 指向同一个对象， System.out.println("s1.equals(s2) : " + (s1.equals(s2))); //↑ true 值相等 //↑------------------------------------------------------over /** * 情景二：关于new String("") * */ String s3 = new String("abc"); //↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中； //↑ 还有一个对象引用s3存放在栈中 String s4 = new String("abc"); //↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象 System.out.println("s3 == s4 : "+(s3==s4)); //↑false s3和s4栈区的地址不同，指向堆区的不同地址； System.out.println("s3.equals(s4) : "+(s3.equals(s4))); //↑true s3和s4的值相同 System.out.println("s1 == s3 : "+(s1==s3)); //↑false 存放的地区多不同，一个栈区，一个堆区 System.out.println("s1.equals(s3) : "+(s1.equals(s3))); //↑true 值相同 //↑------------------------------------------------------over /** * 情景三： * 由于常量的值在编译的时候就被确定(优化)了。 * 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。 * 这行代码编译后的效果等同于： String str3 = "abcd"; */ String str1 = "ab" + "cd"; //1个对象 String str11 = "abcd"; System.out.println("str1 = str11 : "+ (str1 == str11)); //↑------------------------------------------------------over /** * 情景四： * 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。 * * 第三行代码原理(str2+str3)： * 运行期JVM首先会在堆中创建一个StringBuilder类， * 同时用str2指向的拘留字符串对象完成初始化， * 然后调用append方法完成对str3所指向的拘留字符串的合并， * 接着调用StringBuilder的toString()方法在堆中创建一个String对象， * 最后将刚生成的String对象的堆地址存放在局部变量str3中。 * * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。 * str4与str5地址当然不一样了。 * * 内存中实际上有五个字符串对象： * 三个拘留字符串对象、一个String对象和一个StringBuilder对象。 */ String str2 = "ab"; //1个对象 String str3 = "cd"; //1个对象 String str4 = str2+str3; String str5 = "abcd"; System.out.println("str4 = str5 : " + (str4==str5)); // false //↑------------------------------------------------------over /** * 情景五： * JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。 * 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中 */ String str6 = "b"; String str7 = "a" + str6; String str67 = "ab"; System.out.println("str7 = str67 : "+ (str7 == str67)); //↑str6为变量，在运行期才会被解析。 final String str8 = "b"; String str9 = "a" + str8; String str89 = "ab"; System.out.println("str9 = str89 : "+ (str9 == str89)); //↑str8为常量变量，编译期会被优化 //↑------------------------------------------------------over }

总结：

1.String类初始化后是不可变的(immutable)

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原 因了，因为StringBuffer是可改变的。

下面是一些String相关的常见问题：

String中的final用法和理解 final StringBuffer a = new StringBuffer(“111”); final StringBuffer b = new StringBuffer(“222”); a=b;//此句编译不通过 final StringBuffer a = new StringBuffer(“111”); a.append(“222”);// 编译通过

可见，final只对引用的”值”(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

2.代码中的字符串常量在编译的过程中收集并放在class文件的常量区中，如”123”、”123”+”456”等，含有变量的表达式不会收录，如”123”+a。

3.JVM在加载类的时候，根据常量区中的字符串生成常量池，每个字符序列如”123”会生成一个实例放在常量池里，这个实例是不在堆里的，也不会被GC，这个实例的value属性从源码的构造函数看应该是用new创建数组置入123的，所以按我的理解此时value存放的字符数组地址是在堆里，如果有误的话欢迎大家指正。

4.使用String不一定创建对象

c#基础系列之System.String的深入理解

前言

几乎任何一个项目都离不开对字符串的处理，在C和C++编程中，许多程序的漏洞都是由于字符串缓冲区溢出造成的。为了避免在C#中出现类似的问题，同时也为了使用更方便，C#中专门设置了两个字符串处理类：String类和StringBuilder类。

本文主要给大家介绍了关于c#基础系列之string的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧

扩展阅读：深入理解值类型和引用类型

基本概念

string（严格来说应该是System.String） 类型是我们日常coding中用的最多的类型之一。那什么是String呢?^ ~ ^

String是一个不可变的连续16位的Unicode代码值的集合，它直接派生自System.Object类型。

与之对应的还有一个不常用的安全字符串类型System.Security.SecureString，它会在非托管的内存上分配，以便避开GC的黑手。主要用于安全性特高的场景。[具体可查看msdn这里不展开讨论了。=>msdn查看详情

特性

• 由于String类型直接派生于Object，所以它是引用类型，那就意味着String对象的实例总是存在于堆上。
• String具有不变性，也就是说一旦初始化，它的值将永远不变。
• String类型是封闭的，换言之，你的任何类型不能继承String。
• 定义字符串实例的关键字string只是System.String 类型的一个映射。

注意事项

• 关于字符串中的回车符和换行符一般大家喜欢直接硬编码‘\r\n'',但是不建议这么做，一旦程序迁移到其他平台，将出现错误。相反，推荐使用System.Environment类的NewLine属性来生成回车符和换行符，可以跨平台使用的。
• 常量字符串的拼接和非常量字符串在CLR中行为是不一样的。具体请查看性能部分。
• 字符串之前加@符号会改变编译器的行为，如果加了@符号，编译器会把String中的转义字符视为正常字符来显示。也就是我定义的什么内容就是什么内容，主要在使用文件路径或者目录字符串中使用。以下两个String内容的输出将完全一致。

  static void Main(string[] args)
   {
    string a = "c:\\temp\\1";
    string b = @"c:\temp\1";
    Console.WriteLine(a);
    Console.WriteLine(b);
    Console.Read();   
   } 

性能

• c#的编译器直接支持String类型，并将定义的常量字符串在编译期直接存放到模块的元数据中。然后会在运行时直接加载。这也说明String类型的常量在运行时是有特殊待遇的。
• 由于字符串的不变性，也就意味着多个线程同时操作该字符串不会有任何线程安全的问题。这在某些共享配置的设计中很有用。
• 如果程序经常会对比重复度比较高的字符串，这会造成性能上的影响，因为对比字符串是要经过几个步骤的。为此CLR引入了一个字符串重用的技术，学名叫做‘字符串留用''。原理就是：CLR会在初始化的时候创建一个内部的哈希表，key是字符串，value就是留用字符串在托管堆上的引用。
  String类型提供了两个静态方法来操作这个哈希表：

String.Intern

String.IsInterned

具体请查看msdn(https://msdn.microsoft.com/zh-cn/library/system.string.isinterned(v=vs.110).aspx)

但是c#编译器默认是不开启字符串留用功能的，因为如果程序大量把字符串留用，应用程序总体性能可能会变得更慢。（微软也是挺纠结的，程序员TMD的更纠结）

如果我们的程序中有很多个一模一样值的常量字符串， c#的编译器会在编译期间把这些字符串合并为一个并写入模块的元数据中，然后修改所有引用该字符串的代码。这也是一种字符串重用技术，学名‘字符串池''。这意味着什么呢？这意味着所有值相同的常量字符串其实引用的是同一个内存地址的实例，在相同值非常多的情况下能显著提高性能和节省大量内存。

string s1 = "hello 大菜";
string s2 = "hello 大菜";
unsafe
{
 fixed (char* p = s1)
 {
  Console.WriteLine("字符串地址= 0x{0:x}", (int)p);

 }
 fixed (char* p = s2)
 {
  Console.WriteLine("字符串地址= 0x{0:x}", (int)p);

 }
} 

输出结果：

字符串地址= 0x80002d84
字符串地址= 0x80002d84

可见实例的值只分配了一次，但是有一点需要说明，字符串仅用于编译期能确定值的字符串，也就是常量字符串。如果我的程序修改为：

args = new string[] { "dfasfdsa"};
string s1 = "hello 大菜"+ args[0];
string s2 = "hello 大菜"+args[0];
unsafe
{
 fixed (char* p = s1)
 {
  Console.WriteLine("字符串地址= 0x{0:x}", (int)p);

 }
 fixed (char* p = s2)
 {
  Console.WriteLine("字符串地址= 0x{0:x}", (int)p);

 }
}

运行结果：

字符串地址= 0x2e3c
字符串地址= 0x2e7c

平时coding避免不了字符串的连接，如果一个频繁拼接字符串的场景下使用‘+''，对程序整体性能和GC影响还是挺大的，为此c#推出了 StringBuilder类型来优化字符串的拼接。相对于String类型的不变性来说，StringBuilder更像是可变的字符串类型。它的底层数据结构是一个Char的数组。另外还有容量（默认为16），最大容量（默认为int.MaxValue）等属性。StringBuilder的优势在于字符总数未超过‘容量''的时候，底层数组不会重新分配，这和String每次都重新分配形成最大的对比。如果字符总数超过‘容量''，StringBuilder会自动倍增容量属性，用一个新的数组来容纳原来的值，原来数组将会被GC回收。可见如果StringBuilder频繁的动态扩容也会损害性能，但是影响可能会比String小的多。 合理的设置StringBuilder初始容量对程序有很大帮助。测试如下：

int count = 100000;
Stopwatch sw = new Stopwatch();
sw.Start();
string s = "";
for (int i = 0; i < count; i++)
 {
  s += i.ToString();
 }
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);

运行结果：

14221

查看GC的情况

Gc执行的是如此频繁。 性能是可想而知的。接着看一下StringBuilder

int count = 100000;
Stopwatch sw = new Stopwatch();
sw.Start();   
StringBuilder sb = new StringBuilder();//听说程序员都这样命名StringBuilder
for (int i = 0; i < count; i++)
 {
 sb.Append(i.ToString());
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);

运行结果：

12

GC情况：

几乎没有GC（可能还未达到触发GC的临界点），如果我合理初始化了StringBuilder 容量，生产环境中结果差距将会更大。 呵呵 ^ ~ ^

其他

关于字符串留用和字符串池

一个程序集加载的时候，CLR默认会留用该程序集元数据中描述的所有文本常量字符串。由于可能会出现额外的哈希表查找造成的性能下降的现象，所以现在可以禁用这个特性了。

coding中我们平常比较两个字符串是否相等，那这个过程是怎么样的呢？

• 首先判断字符的数量是否相等。
• CLR逐个对比字符最终确定是否相等。

这个场景是适合字符串留用的。因为不再需要经过以上的两个步骤，直接哈希表拿到value就可以对比确定了。

关于字符串拼接性能

基于以上所有知识，那是不是StringBuilder拼接字符串性能永远都高于符号‘+''呢？答案是否定的。

 static void Main(string[] args)
  {
   int count = 10000000;
   Stopwatch sw = new Stopwatch();
   sw.Start();   
   string str1 = "str1", str2 = "str2", str3 = "str3";
   for (int i = 0; i < count; i++)
   {
    string s = str1 + str2 + str3;
   }
   sw.Stop();
   Console.WriteLine($@"+用时： {sw.ElapsedMilliseconds}" );

   sw.Reset();
   sw.Start();
   for (int i = 0; i < count; i++)
   {
    StringBuilder sb = new StringBuilder();//听说程序员都这样命名StringBuilder
    sb.Append(str1).Append(str2).Append(str3);
   }
   sw.Stop();
   Console.WriteLine($@"StringBuilder.Append 用时： {sw.ElapsedMilliseconds}");

   Console.Read();
  }

运行结果：

+用时： 553
StringBuilder.Append 用时： 975

符号‘+''最终会调用String.Concat方法，当同时连接几个字符串时，并不是每连接一个都分配一次内存，而是把几个字符都作为 String.Concat方法的参数，只分配一次内存。所以在拼接的字符串个数比较少的场景下，String.Concat 性能是略高于StringBuilder.Append。string.Format 方法最终调用的是StringBuilder，这里不做展开讨论了，请自行参考其他文档。

所以万事都不是绝对的！！每个事物都有适合自己的场景,我们都需要自己去探索。（程序员太累了）

以上都是非生产环境测试结果，如果错误，请及时指正

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。

Java String的理解

public final class String
    implements java.io.Serializable,Comparable<String>,CharSequence {
    // ....
}

public final class String
    implements java.io.Serializable,CharSequence {
    private final char value[];

    public String() {
        this.value = "".value;
    }
}

// 直接赋值
String s = "llll";

public String() {
    this.value = "".value;
}

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

// 根据整个字符数组创建字符串
public String(char value[]) {
    this.value = Arrays.copyOf(value,value.length);
}

//截取部分字符数组创建字符串
public String(char value[],int offset,int count) {
    if (offset < 0) {
        throw new Stringindexoutofboundsexception(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new Stringindexoutofboundsexception(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new Stringindexoutofboundsexception(offset + count);
    }
    this.value = Arrays.copyOfRange(value,offset,offset+count);
}

// 没有使用过。。。
public String(int[] codePoints,int count) {
    if (offset < 0) {
        throw new Stringindexoutofboundsexception(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new Stringindexoutofboundsexception(count);
        }
        if (offset <= codePoints.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > codePoints.length - count) {
        throw new Stringindexoutofboundsexception(offset + count);
    }

    final int end = offset + count;

    // Pass 1: Compute precise size of char[]
    int n = count;
    for (int i = offset; i < end; i++) {
        int c = codePoints[i];
        if (Character.isBmpCodePoint(c))
            continue;
        else if (Character.isValidCodePoint(c))
            n++;
        else throw new IllegalArgumentException(Integer.toString(c));
    }

    // Pass 2: Allocate and fill in char[]
    final char[] v = new char[n];

    for (int i = offset,j = 0; i < end; i++,j++) {
        int c = codePoints[i];
        if (Character.isBmpCodePoint(c))
            v[j] = (char)c;
        else
            Character.toSurrogates(c,v,j++);
    }

    this.value = v;
}

// 需要指定编码集，根据传递的编码集解码
public String(byte bytes[],int length,String charsetName)
        throws UnsupportedEncodingException {
    if (charsetName == null)
        throw new NullPointerException("charsetName");
    checkBounds(bytes,length);
    this.value = StringCoding.decode(charsetName,bytes,length);
}
public String(byte bytes[],Charset charset) {
    if (charset == null)
        throw new NullPointerException("charset");
    checkBounds(bytes,length);
    this.value =  StringCoding.decode(charset,length);
}

// 根据传入的字节数组和其长度创建字符串
public String(byte bytes[],int length) {
    checkBounds(bytes,length);
    this.value = StringCoding.decode(bytes,length);
}

public String(byte bytes[]) {
    this(bytes,bytes.length);
}

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(),buffer.length());
        }
    }

    public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(),builder.length());
    }

// 预留方法，默认访问类型，通过直接赋值创建字符串
String(char[] value,boolean share) {
    // assert share : "unshared not supported";
    this.value = value;
}

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

public static String valueOf(int i) {
    return Integer.toString(i);
}

public static String valueOf(long l) {
    return Long.toString(l);
}

public static String valueOf(float f) {
    return Float.toString(f);
}

public static String valueOf(double d) {
    return Double.toString(d);
}

public static String valueOf(char data[]) {
    return new String(data);
}

public static String valueOf(char data[],int count) {
    return new String(data,count);
}

public static String valueOf(char c) {
    char data[] = {c};
    return new String(data,true);
}

public static String copyValueOf(char data[],count);
}

public static String copyValueOf(char data[]) {
    return new String(data);
}

public static String valueOf(boolean b) {
    return b ? "true" : "false";
}

public static String format(String format,Object... args) {
    return new Formatter().format(format,args).toString();
}

public static String format(Locale l,String format,Object... args) {
    return new Formatter(l).format(format,args).toString();
}

public native String intern();

Java 中 String 类深入理解

前言
String 对象作为 Java 语言中重要的数据类型之一，是我们平时编码最常用的对象之一，因此也是内存中占据空间最大的一个对象。然而很多人对它是一知半解，今天我们就来好好聊一聊这个既熟悉又陌生的 String
一、 String 认识你，你认识它么？
假如面试的时候问你，什么是 String（或者谈谈你对 String 的理解）？你会如何回答？“String 是基础对象类型之一，是 Java 语言中重要的数据类型之一”。恐怕这是大多数人的回答，能力强些的可能会说，String 底层是用 char [ ] 数组来实现的；如果面试官让你再继续呢？估计很多人会一脸尴尬，脑海里极力搜索关于 String 的相关知识，最后也只能恨自己平时对 String 关注的太少。下面就让我们一步一步地去认识 String。
首先，来看一个面试经常遇到，错误率又很高的问题：

1 String str1 = “java”;
2 String str2 = new String(“java”);
3 String str3= str2.intern();
4 System.out.println(str1 == str2);
5 System.out.println(str2 == str3);
6 System.out.println(str1 == str3);

答案先不揭晓，各位先想一下，咱们继续往下看：
二、String 对象的实现
我们把 String 对象的实现分为三个阶段来分析：java7 之前的版本、java7/8 版本、java8 之后的版本。
1、 java7 之前的版本中，String 对象中主要由四个成员变量：char []、偏移量 offset、字符数量 count、哈希值 hash。String 对象通过 offset 和 count 来定位 char []，这么做可以高效、快速地共享数组对象，节省内存空间，但这种方式很有可能会导致内存泄漏。
2、 java7/8 版本中，String 去除了 offset 和 count 两个变量。这样的好处是 String 对象占用的内存稍微少了些，同时，String.substring () 方法也不再共享 char []，从而解决了使用该方法可能导致的内存泄漏问题。
3、 java8 之后的版本中，char [] 属性改为了 byte [] 属性，增加了一个新的属性 coder，它是一个编码格式的标识。为什么这么做呢？我们知道一个 char 字符占 16 位，2 个字节。这种情况下，存储单字节编码内的字符（占一个字节的字符）就显得非常浪费。JDK1.9 的 String 类为了节约内存空间，于是使用了占 8 位，1 个字节的 byte 数组来存放字符串。而新属性 coder 的作用是，在计算字符串长度或者使用 indexOf（）函数时，我们需要根据这个字段，判断如何计算字符串长度。coder 属性默认有 0 和 1 两个值，0 代表 Latin-1（单字节编码），1 代表 UTF-16。如果 String 判断字符串只包含了 Latin-1，则 coder 属性值为 0，反之则为 1。
三、String 是不可变对象
1、为什么 String 是不可变对象
很多人背面试题的时候想必都对此很熟悉，那为什么 String 对象是不可变的呢？你有想过这其中的原因么？通过源码我们知道，String 类被 final 关键字修饰了，而且变量 char [] 也被 final 修饰了。Java 语法告诉我们：被 final 修饰的类不可被继承，被 final 修饰的变量不可被改变，一旦赋值了初始值，该 final 变量的值就不能被重新赋值，即不可更改，而 char [] 被 final+private 修饰，说明 String 对象不可被更改。即 String 对象一旦创建成功，就不能再对它进行改变。
2、为什么 String 被设计成不可变对象
首先，是为了保证 String 对象的安全性，避免被恶意串改。比如将值为 “abc” 的引用赋值给 str 对象，即 String str = “abc”，如果此时有人恶意将 “abc” 改为 “abcd” 或其他值就会造成意想不到的错误。
其次，确保属性值 hash 不频繁变动，保证其唯一性。
最后，为实现字符串常量池提供方便。
举一个反例来证明 String 对象的不可变性
针对 String 对象不可变性，有人可能会说：对于一个 String str =“hello”，然后改为 String str =“world”，这个时候 str 的值变成了 “world”，str 值确实改变了，为什么还说 String 对象不可变呢？
首先，我们来解释一下对象和引用。对象在内存中是一块内存地址，str 则是一个指向该内存地址的引用，所以在这个例子中，第一次赋值的时候，创建了一个 “hello” 对象，str 引用指向 “hello” 地址；第二次赋值的时候，又重新创建了一个对象 “world”，str 引用指向了 “world”，但 “hello” 对象依然存在于内存中。也就是说 str 并不是对象，而只是一个对象引用。真正的对象依然还在内存中，没有被改变。所以在 Java 中要比较两个对象是否相等，通常是用 “==”，而要判断两个对象的值是否相等，则需要用 equals 方法来判断。
四、String 常量池
在 java 中，创建字符串通常有两种方式：一种是通过字符串常量池的形式，比如 String str = “abcd”；另一种是直接通过 new 的形式，如 String string = new String（“abcd”）；
针对第一种方式创建字符串时，JVM 首先会检查该对象是否存在于字符串常量池中，如果存在，就返回该引用，否则在常量池中创建新的字符串对象，然后将引用返回。这种方式可以减少同一个值的字符串对象的重复创建，节约内存。
采用 new 形式创建字符串时，首先在编译类文件时，"abcd" 常量字符串将会放入到常量结构中，在类加载时，“abcd"将会在常量池中创建；其次，在调用 new 时，JVM 命令将会调用 String 的构造函数，同时引用常量池中的"abcd” 字符串，在堆内存中创建一个 String 对象；最后，string 将引用 String 对象。
五、String.intern () 方法详解
先来看一个示例：

String a =new String("abc").intern();
  String b = new String("abc").intern();
  System.out.print(a==b);

你觉得输出的是 false 还是 true？
答案是：true
在字符串常量中，默认会将对象放入常量池中；在字符串变量中，对象是会创建在堆内存中，同时也会在常量池中创建一个字符串对象，复制到堆内存对象中，并返回堆内存对象引用。如果调用 intern () 方法，会去查看字符串常量池中是否有等于该对象的字符串，如果没有，就在常量池中新增该对象，并返回该对象引用；如果有，就返回常量池中的字符串引用。堆内存中原有的对象由于没有引用指向它，将会通过垃圾回收器回收。
所以针对上面的例子中，在一开始创建 a 变量时，会在堆内存中创建一个对象，同时会在加载类时，在常量池中创建一个字符串对象，在调用 intern () 方法之后，会去常量池中查找是否有等于该字符串的对象，有就返回引用。在创建 b 字符串变量时，也会在堆中创建一个对象，此时常量池中有该字符串对象，就不再创建。调用 intern 方法则会去常量池中判断是否有等于该字符串的对象，发现有等于 "abc" 字符串的对象，就直接返回引用。而在堆内存中的对象，由于没有引用指向它，将会被垃圾回收。所以 a 和 b 引用的是同一个对象。
看完这些内容后，文章开头的问题，相比你也有了答案了。分别是：false、false、true。

六、String、StringBuffer 和 StringBuilder 的区别
1. 对象的可变与不可变
　　String 是不可变对象，原因上面的内容已经解释过了，这里不再赘述。
　　StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存数据，这两种对象都是可变的。如下：
char[ ] value;
2. 是否是线程安全
　　String 中的对象是不可变的，也就可以理解为常量，所以是线程安全。
　　AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。
　　StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

1  public synchronized StringBuffer reverse() {
   
2      super.reverse();
3      return this;
4  }
5
6  public int indexOf(String str) {
   
7      return indexOf(str, 0);        //存在 public synchronized int indexOf(String str, int fromIndex) 方法
8  }

StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
3.StringBuilder 与 StringBuffer 共同点
　　StringBuilder 与 StringBuffer 有公共的抽象父类 AbstractStringBuilder。
　　抽象类与接口的一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。
　　StringBuilder、StringBuffer 的方法都会调用 AbstractStringBuilder 中的公共方法，如 super.append (…)。只是 StringBuffer 会在方法上加 synchronized 关键字，进行同步。
如果程序不是多线程的，那么使用 StringBuilder 效率高于 StringBuffer。

下面来几道测试题，看看自己对 String 究竟掌握了多少
七、测试题
test1、如下代码中创建了几个对象

1 String str1 = "abc";
2 String str2 = new String("abc");

对于 1 中的 String str1 = “abc”，首先会检查字符串常量池中是否含有字符串 abc，如果有则直接指向，如果没有则在字符串常量池中添加 abc 字符串并指向它。所以这种方法最多创建一个对象，有可能不创建对象。
对于 2 中的 String str2 = new String（“abc”）, 首先会在堆内存中申请一块内存存储字符串 abc,str2 指向其内存块对象。同时还会检查字符串常量池中是否含有 abc 字符串，若没有则添加 abc 到字符串常量池中。所以 new String () 可能会创建两个对象。
所以如果以上两行代码在同一个程序中，则 1 中创建了 1 个对象，2 中创建了 1 个对象。如果将这两行代码的顺序调换一下，则 String str2 = new String (“abc”) 创建了两个对象，而 String str1 = "abc" 没有创建对象。

test2、看看下面的代码创建了多少个对象：

1     String temp="apple";  
2     for(int i=0;i<1000;i++) {
     
3           temp=temp+i;  
4     }

答案：1001 个对象。

test3、下面的代码创建了多少个对象：

1     String temp = new String("apple")  
2     for(int i=0;i<1000;i++) {
     
3            temp = temp+i;  
4     }

答案：1002 个对象。

test4：

1 String ok = "ok";  
2 String ok1 = new String("ok");  
3 System.out.println(ok == ok1);//fasle 

ok 指向字符串常量池，ok1 指向 new 出来的堆内存块，new 的字符串在编译期是无法确定的。所以输出 false。

test5：

1 String ok = "apple1";  
2 String ok1 = "apple"+1;  
3 System.out.println(ok==ok1);//true 

编译期 ok 和 ok1 都是确定的，字符串都为 apple1，所以 ok 和 ok1 都指向字符串常量池里的字符串 apple1。指向同一个对象，所以为 true。

test6：

1 String ok = "apple1";  
2 int temp = 1;  
3 String ok1 = "apple"+temp;  
4 System.out.println(ok==ok1);//false

主要看 ok 和 ok1 能否在编译期确定，ok 是确定的，放进并指向常量池，而 ok1 含有变量导致不确定，所以不是同一个对象。输出 false。

test7：

1 String ok = "apple1";  
2 final int temp = 1;  
3 String ok1 = "apple"+temp;  
4 System.out.println(ok==ok1);//true 

ok 确定，加上 final 后使得 ok1 也在编译期能确定，所以输出 true。

test8：

1 public static void main(String[] args) {
       
 2     String ok = "apple1";  
 3     final int temp = getTemp();  
 4     String ok1 = "apple"+temp;  
 5     System.out.println(ok==ok1);//false 
 6 }  
 7   
 8 public static int getTemp(){
     
 9     return 1;  
10 }

ok 一样是确定的。而 ok1 不能确定，需要运行代码获得 temp, 所以不是同一个对象，输出 false。

以上内容如有不对的地方，还请各位指正！多谢！

java 中Spring task定时任务的深入理解

这篇文章主要介绍了java 中Spring task定时任务的深入理解的相关资料,这里提供实例来帮助大家理解task定时任务，希望大家通过本文掌握这部分内容，需要的朋友可以参考下

java 中Spring task定时任务的深入理解

在工作中有用到spring task作为定时任务的处理，spring通过接口TaskExecutor和TaskScheduler这两个接口的方式为异步定时任务提供了一种抽象。这就意味着spring容许你使用其他的定时任务框架，当然spring自身也提供了一种定时任务的实现：spring task。spring task支持线程池，可以高效处理许多不同的定时任务。同时，spring还支持使用Java自带的Timer定时器和Quartz定时框架。限于篇幅，这里将只介绍spring task的使用。

其实，官方文档已经介绍地足够详细，只不过都是英文版，所以为了更好地理解并使用spring task，首先会对spring task的实现原理做一个简单的介绍，然后通过实际代码演示spring task是如何使用的。这里会涉及到一个很重要的知识点：cron表达式。

TaskExecutor和TaskScheduler

TaskExecutor是spring task的第一个抽象，它很自然让人联想到jdk中concurrent包下的Executor，实际上TaskExecutor就是为区别于Executor才引入的，而引入TaskExecutor的目的就是为定时任务的执行提供线程池的支持，那么，问题来了，为什么spring不直接使用jdk自带的Executor呢？TaskExecutor源码如下？

public interface TaskExecutor extends Executor { void execute(Runnable var1); }

那么，答案很显然，TaskExecutor提供的线程池支持也是基于jdk自带的Executor的。用法于Executor没有什么不同。

TaskScheduler是spring task的第二个抽象，那么从字面的意义看，TaskScheduler就是为了提供定时任务的支持咯。TaskScheduler需要传入一个Runnable的任务做为参数，并指定需要周期执行的时间或者触发器，这样Runnable任务就可以周期性执行了。传入时间很好理解，有意思的是传入一个触发器（Trigger）的情况，因为这里需要使用cron表达式去触发一个定时任务，所以有必要先了解下cron表达式的使用。

在spring 4.x中已经不支持7个参数的cronin表达式了，要求必须是6个参数（具体哪个参数后面会说）。cron表达式的格式如下：

{秒} {分} {时} {日期（具体哪天）} {月} {星期}

秒：必填项，允许的值范围是0-59，支持的特殊符号包括

, - * /，,表示特定的某一秒才会触发任务，-表示一段时间内会触发任务，*表示每一秒都会触发，/表示从哪一个时刻开始，每隔多长时间触发一次任务。

分：必填项，允许的值范围是0-59，支持的特殊符号和秒一样，含义类推

时：必填项，允许的值范围是0-23，支持的特殊符号和秒一样，含义类推

日期：必填项，允许的值范围是1-31，支持的特殊符号相比秒多了?，表示与{星期}互斥，即意味着若明确指定{星期}触发，则表示{日期}无意义，以免引起冲突和混乱。

月：必填项，允许的值范围是1-12（JAN-DEC），支持的特殊符号与秒一样，含义类推

星期：必填项，允许值范围是1~7 (SUN-SAT),1代表星期天（一星期的第一天），以此类推，7代表星期六，支持的符号相比秒多了?，表达的含义是与{日期}互斥，即意味着若明确指定{日期}触发，则表示{星期}无意义。

比如下面这个cron表达式：

// 表达的含义是：每半分钟触发一次任务 30 * * * * ?

spring提供了一个crontrigger，通过传入一个Runnable任务和crontrigger，就可以使用cron表达式去指定定时任务了，是不是非常方面。实际上，在工程实践上，cron表达式也是使用很多的。实际上，是执行了下面的代码：

scheduler.schedule(task, new crontrigger("30 * * * * ?"));

TaskScheduler抽象的好处是让需要执行定时任务的代码不需要指定特定的定时框架（比如Timer和Quartz）。TaskScheduler的更简单的实现是ThreadPoolTaskScheduler,它实际上代理一个jdk中的SchedulingTaskExecutor，并且也实现了TaskExecutor接口，所以需要经常执行定时任务的场景可以使用这个实现（Spring推荐）。我们再来看一下TaskExecutor和TaskScheduler的类继承关系：

通常而言，使用spring task实现定时任务有两种方式：注解和xml配置文件。这里使用xml配置文件的方式加以说明。

实战

创建Maven工程，pom.xml:

4.0.0com.rhwayfunsring-task-demo1.0-SNAPSHOTorg.springframeworkspring-context4.2.4.RELEASEOrg.apache.maven.pluginsmaven-compiler-plugin3.5.11.81.8

开发需要执行定时任务的方法：

package com.rhwayfun.task; import org.springframework.stereotype.Component; import java.time.LocalDateTime; /** * @author ZhongCB * @date 2016年09月10日 14:30 * @description */ @Component public class App { public void execute1(){ System.out.printf("Task: %s, Current time: %sn", 1, LocalDateTime.Now()); } public void execute2(){ System.out.printf("Task: %s, Current time: %sn", 2, LocalDateTime.Now()); } public void execute3(){ System.out.printf("Task: %s, Current time: %sn", 3, LocalDateTime.Now()); } public void execute4(){ System.out.printf("Task: %s, Current time: %sn", 4, LocalDateTime.Now()); } public void execute5(){ System.out.printf("Task: %s, Current time: %sn", 5, LocalDateTime.Now()); } public void execute6(){ System.out.printf("Task: %s, Current time: %sn", 6, LocalDateTime.Now()); } public void execute7(){ System.out.printf("Task: %s, Current time: %sn", 7, LocalDateTime.Now()); } public void execute8(){ System.out.printf("Task: %s, Current time: %sn", 8, LocalDateTime.Now()); } public void execute9(){ System.out.printf("Task: %s, Current time: %sn", 9, LocalDateTime.Now()); } public void execute10(){ System.out.printf("Task: %s, Current time: %sn", 10, LocalDateTime.Now()); } public void execute11(){ System.out.printf("Task: %s, Current time: %sn", 11, LocalDateTime.Now()); } }

spring配置文件如下：

编写测试代码：

package com.rhwayfun.task; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClasspathXmlApplicationContext; /** * @author ZhongCB * @date 2016年09月10日 14:55 * @description */ public class AppTest { public static void main(String[] args) { ApplicationContext context = new ClasspathXmlApplicationContext("classpath:/app-context-task.xml"); } }

运行测试代码，控制台会定时输出每个定时任务的日志信息，说明测试通过。

小插曲

由于项目使用jdk 1.8进行开发，所以初始的时候每次pom文件发生修改，编译器的版本又变成了jdk 1.5，后面发现需要在pom文件中添加build便签那部分才能将默认的编译器进行修改。也算一个小收获了。

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

我们今天的关于java String的深入理解和java string详解的分享已经告一段落，感谢您的关注，如果您想了解更多关于c#基础系列之System.String的深入理解、Java String的理解、Java 中 String 类深入理解、java 中Spring task定时任务的深入理解的相关信息，请在本站查询。