御风逍遥
御风逍遥

Java笔记

java笔记

  1. Main.java文件中的入口类（即包含main方法）的访问权限不一定非要设定为public，不加public也是可以运行的。但main方法必须是public。

  2. 以/**开头 */结尾的注释可以自动生成文档。

  3. java包含8种基本数据类型：4种整型（byte、short、int、long）、2种浮点型（float(有效位6~7)、double(有效位15)）、char、boolean。

          字节数    其他
 byte:  1    
 short: 2
 int:   4       范围正好超过20亿
 long:  8       加L、l后缀
 float: 4       加F、f后缀
 double:8
 char:  2
 boolean:

十六进制0x开头，八进制以0开头，二进制0b开头，如0b1001 = 9;
数字之间可以加下划线，如：123_4567,0b1000_0011。

java的整形数据没有无符号类型（unsigned）。
对浮点型数据，有3个特定值：

Double.POSITVE_INFINITY:正无穷

Double.NEGATIVE_INFINITY:负无穷

Double.NaN：不是一个数字，表示0/0或者负数的平方根的结果。

浮点型不要用 == 比较。应该比较他们的差的绝对值是否小于某一个很小的数。

char类型采用了unicode编码，unicode编码单元可以表示为十六进制，其范围是：\u0000~\uffff。一般char类型的表示方式有3种：

  1. 使用单引号:'0','a','B'。
  2. 使用转义序列符，针对一些特殊字符： \b,\n,\,",'等
  3. 使用十六进制值，如:\u0035='5',\u0008=\b

局部变量在使用(除了对其赋值操作)之前必须进行显式的初始化。且变量的声明尽量靠近第一次使用的地方。

关键字final修饰的变量只能被赋值一次，之后就不能再更改了，习惯上常量名使用全大写。final修饰的类的成员变量，必须保证在初始化函数之后其已经被赋值，否则编译报错。全局类常量 public static final修饰`。

位运算符：&按位与、|按位或、^按位异或、~按位非

<<左移，低位补0；>>右移，高位用符号位填充；>>>右移，高位用0填充

注意对移动运算需要进行模32的操作，如1<<35 = 1<<3

数学函数与常量：Math.sqrt(double)求平方根，幂运算：Math.pow(x,a)求x的a次方。其反函数求对数：Math.exp，Math.log，Math.log10。 常量：Math.PI,Math.E。

数值转换

分为自动转换和强制类型转换。

自动转换：编译器不会报警，即转换后的类型数据范围大于转换前的类型。

无信息丢失的转换：
byte->short->int->long
char->int->double
float->double
精度丢失的转换：
long->dobule
long->float
int->float

这里int转float的精度丢失不太理解，如

int n = 123456789;
float f = n;//f is 1.23456792E8

浮点数参考教程：

http://blog.csdn.net/b2b160/article/details/4492519
http://www.ruanyifeng.com/blog/2010/06/ieee_floating-point_representation.html

http://www.zengdongwu.com/article1.html

对上面的数值进行二元操作时，遵循如下规则：

  1. 如果2个操作数中有一个是double类型，另一个操作数就会转换为double类型
  2. 否则，如果2个操作数中有一个是float类型，另一个操作数就会转换为float类型
  3. 否则，如果2个操作数中有一个是long类型，另一个操作数就会转换为long类型
  4. 否则，2个操作数都被转换为int类型

强制类型转换：
将数据范围大的类型转换为数据范围小的类型

如 double x = 1.66;
int nx = (int)x;

如果想四舍五入的转换：int nx = (int)Math.round(x)

    System.out.println("floor:");//地板  取最小 返回double
    System.out.println(Math.floor(5.1));
    System.out.println(Math.floor(5.9));
    System.out.println(Math.floor(-5.1));
    System.out.println(Math.floor(-5.9));
    
    System.out.println("ceil:");//天花板  取最大 返回double
    System.out.println(Math.ceil(5.1));
    System.out.println(Math.ceil(5.9));
    System.out.println(Math.ceil(-5.9));
    System.out.println(Math.ceil(-5.1));
    
    System.out.println("round：");//四舍五人，返回long
    System.out.println(Math.round(5.1));
    System.out.println(Math.round(5.9));
    System.out.println(Math.round(-5.1));
    System.out.println(Math.round(-5.9));
    
    输出：
    floor:
    5.0
    5.0
    -6.0
    -6.0
    ceil:
    6.0
    6.0
    -5.0
    -5.0
    round：
    5
    6
    -5
    -6

如果转换的结果类型超出了目标类型的表示范围，则会截断成一个完全不同的值：（byte）300的实际值为44。

不要再boolean与任何类型之间转换，会发生错误，只有极少数才需要将Boolean型转为数值类型，可以使用 b ? 1 : 0

枚举类型：

enum Size {SMALL, MEDIUM, LARGE};
Size s = Size.SMALL;

Size类型的变量只存储这个枚举类型声明的某个枚举值或者null,null表示这个变量没有设置任何值。

字符串：

字符串就是Unicode字符序列，String类被定义为final类型，表示字符串是不可被修改的，这样编译器就可以让字符串共享，java的设计者认为共享带来的高效远远胜过提取、拼接字符串所带来的低效率。

子串提取：str.subString(a,b)，a表示第一个要提取的字符的位置，b表示第一个不想提取的字符的位置。这样子串的长度就等于b-a。

代码String str = "hello"；
中str是字符串变量，"hello"是字符串常量。实际上在虚拟机中只有字符串常量是共享的，像+，subString等操作产生的结果是不共享的。

字符串格式化：String.format("%s%d%f%x%c%h%b"，....);
一些输出格式标志：
0:数字前补0 %02x,对10 输出 0a
#： 添加前缀0x（十六进制）或0（八进制），或者包含小数点。
输出日期：System.out.printf("%1$tF %1$tT", new Date());
结果:2016-06-04 19:38:13，其中t标示日期格式化开始，F表示日期格式，2016-06-04；T标示时间格式19:38:13。1$是参数索引，标示将该格式应用在第几个参数上，以$结尾。索引参数是从1开始，不是0。

System.out.printf("%1$x %1$02x %1$#x %1$#X %n",11);
System.out.printf("%1$tF %1$tT \n", new Date());
输出  
b 0b 0xb 0XB 
2016-08-19 16:09:10

可以使用Scanner,PrintWriter对文件进行读写操作。
new Scanner(new File("pathname"))、new PrintWriter(new File(pathname))

常见String面试题：

  1. String s = new String("abc");创建了几个String对象。
  2. String s1 = "abc";
  3. String s2 = "a";
  4. String s3 = s2 + "bc";
  5. String s4 = "a" + "bc";
  6. String s5 = s3.intern();

请问s1==s3是true还是false，s1==s4是false还是true。s1==s5呢？

1.创建了2个String对象，一个是字符串字面常数，在字符串池中。一个是new出来的字符串对象，在堆中。

 s3 = s2 + "bc";相当于 
 s3 = new StringBuilder().append(s2).append("bc").toString();

此题注意两点，因为s2是一个变量，所以s3是运行时才能计算出来的字符串，是new的，在堆中不在字符串池中。s4是通过常量表达式计算出来的，他等同于字符串字面常数，在字符串池中。所以，s1!=s3，s1==s4。再看s5，s5是s3放到字符串池里面返回的对像，所以s1==s5。这里新手要注意的是，s3.intern()方法，是返回字符串在池中的引用，并不会改变s3这个变量的引用，就是s3还是指向堆中的那个"abc"，并没有因调用了intern()方法而改变，实际上也不可能改变。

Java语言规范第三版，第3.10.5小节，String Literals的最后一段如下：

  1. Literal strings within the same class (§8) in the same package (§7) represent references to the same String object (§4.3.1).
  2. Literal strings within different classes in the same package represent references to the same String object.
  3. Literal strings within different classes in different packages likewise represent references to the same String object.
  4. Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
  5. Strings computed by concatenation at run time are newly created and therefore distinct.
  6. The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

首先解释下什么是字符串字面常数(String Literals)，字面常数(Literals)就是你写在源代码里面的值，比如说int i = 6; 6就是一个整数形字面常数。String s = "abc"; “abc”就是一个字符串字面常数。Java中，所有的字符串字面常数都放在上文提到的字符串池里面，是可以共享的，就是说，String s1 = "abc"; String s2 = "abc"; s1，s2都引用的同一个字符串对象，而且这个对象在字符串池里面，因此s1==s2。另外，字符串字面常数是什么时候实例化并放到字符串池里面去的呢？答案是Load Class的时候。

前面三句基本废话，像绕口令一样，意思就是说任何类任何包，值相同的字符串字面常数(String Literals)都引用同一个对象。

第四句是说，通过常量表达式(constant expressions)计算出来的字符串，也算字符串字面常数，就是说他们也在字符串池中。什么才算常量表达式？总结就是，那就是编译时能确定的，就算，运行时才能确定的，就不算。以下为例子

  • String s = 1 + "23";//算，符合第二条Casts to primitive types and casts to type String
  • String s = (2 > 1) + "" ;//算，意味着s=="true"，且这个“true”已经放到字符串池里面去了。
  • String s = (o instanceof Object) + "";//不算，instanceof这个操作符决定了不算。s=="true"，但这个"true"对象在堆中。

留意下面的情况。
final String s2 = "a";
String s3 = s2 + "bc";//算
注意现在的s2+"bc"也算一个常量表达式，理由是s2是一个常量变量(constant variables)，问题又来了，什么是常量变量？规范里也说了，被final修饰，并且通过常量表达式初始化的变量，就是常量变量。变量s2被final修饰，他通过常量表达式"a"初始化，所以s2是一个常量变量，所以s3引用的"abc"，也在字符串池里面。

下面这句话不是很明白：

再举个反例：
final String s2 = getA();//s2不是常量变量，但是s2引用的"a"其实还是在常量池中，这两点不矛盾
public String getA(){return "a"}
String s3 = s2 + "bc";//此时s3不算常量表达式，因为s2不是常量变量
这是时候的s2，就不是常量变量了哦，因为getA()不是一个常量表达式。

另外char中的代码点和代码单元的概念还没弄懂。

大数值类：

BigInteger:add、subtract、multiply、divide、mod、compareTo、valueOf。
BigDecimal:同BigInteger,除了没有mod方法，进行除法时候，需要设定舍入方式，RoundingMOde.HALF_UP就是四舍五入。

数组创建以后，数字元素初始化为0，boolean为false，对象为null。
可以初始化：int[] arr = {1,2,3};
匿名数组 new int[] {1,2,3};
java允许数组长度为0，即new eleType[0]
使用好数组的工具Arrays类中的方法，如toString，sort,asList,equal,fill,copyOf,binarySearch。
要想快速打印二维数组，可以Arrays.deepToString([][])

类之间的关系

依赖（uses-a）UML:---->
聚合（has-a） UML:-> 又称关联
继承（is-a） UML -△
http://blog.csdn.net/zhengzhb/article/details/7190158
http://blog.csdn.net/sfdev/article/details/3906243

  1. 依赖的耦合度最弱，表现为局部变量、方法的形参。
  2. 关联一般用成员变量来实现，有时也用方法形参实现。关联可以是双向的，也可以是单向的。
  3. 聚合是一种比较强的关联关系，一般使用成员变量来标识，对象之间存在整体与部分的关系。
  4. 组合是一种比聚合关系强的关联，它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。为了表示组合关系，常常会使用构造方法来达到初始化的目的。

使用final修饰实例域，则必须确保在构造函数执行后这个域的值被设置。

final修饰符大都应用于基本类型或者不可变的域（类中的每个方法都不会改变其对象，如String）。
final Date date;表示date这个引用不能指向别的实例对象，但date指向的对象是可以改变的。

类中域会初始化成默认值，但为了代码的可读性，尽量进行显示地进行初始化。

如果自定义一个类没有提供构造器，那么会使用系统的无参构造器，如果自己至少写了一个构造器，那么系统就不会提供默认的无参构造器了。

在构造器的第一行使用this（...），则会调用当前类的另一构造器，如果是super(...)则会调用父类的构造器。且子类在执行构造函数时，一定要先对父类进行构造，在构造器的第一行，或者是显示调用super（...）中的一个，或是隐式调用super(),即父类的无参构造函数，前提是父类要有这种无参的构造函数。

类的初始化过程：
在类第一次加载的时候，首先会对静态域初始化，如果没有显示地指定值，则默认的初始值是0，false，null。所有的静态初始化语句以及静态初始化块都将按照它们在类中出现的顺序依次进行初始化。这种静态初始化只会执行一次。

构造器的初始化过程：

  1. 所有的数据域被初始化成默认值
  2. 按照在类中声明出现的次序，依次执行所有的初始化语句和初始化块
  3. 如果构造器的第一行调用了其他构造器，则执行其他构造器
  4. 执行这个构造器的主体
    初始块如果要使用某个域，则该初始化块必须在域的声明之后

总结对象创建的过程：

  1. 首次创建对象时(对象声明不加载class文件)，类中的静态方法/静态字段首次被访问时，java解释器必须先查找类路径，以定位.class文件；
  2. 然后载入.class(这将创建一个Class对象)，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
  3. 当用new XX（）创建对象时，首先在堆上为对象分配足够的存储空间。
  4. 这块存储空间会被清0，这就自动地将对象中的所有基本类型数据都设置成了缺省值（对数字来说就是0，对布尔型和字符型也相同），而引用则被设置成了null。
  5. 按顺序执行所有出现于字段定义处的初始化动作（非静态对象的初始化）。
  6. 执行构造器。

在类的内部，变量定义的先后顺序决定了初始化的顺序，即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。

继承时，对象的初始化过程

  1. 主类的超类由高到低按顺序初始化静态成员，无论静态成员是否为private。
  2. 主类静态成员的初始化。
  3. 主类的超类由高到低进行默认构造方法的调用。注意，在调用每一个超类的默认构造方法前，先进行对此超类进行非静态成员的初始化。
  4. 主类非静态成员的初始化。
  5. 调用主类的构造方法。

import除了能导入类，还可以静态导入：

import static java.lang.System.*;  
out.println("");
exit（0）；

实际上，这种简写形式不利于代码的清晰度。

访问权限修饰符

java提供了public、protect、private三种权限修饰符，4种访问权限，从最大权限到最小权限依次是：public、protected、包访问权限(默认，没有关键字)和private。分别是：

  1. public访问权限，即所有的地方均可以访问。
  2. protect访问权限，同一包内和子类可以访问。
  3. friendly访问权限，即default权限，什么修饰符都不加的权限。同一个包内可以访问。
  4. private访问权限，仅在同一类内才可以访问。

java最多只允许一个java文件中出现一个public类（该类向外提供接口，并与该java文件的名称完全一致）。
当一个java文件中无一个Public类时，表明其仅供包内使用，对外界不可见！

对于类的访问权限只能是：public和什么都不加的包访问权限（但内部类可以是private或protected的）；对于类中的成员的访问权限可以是上述的四种。
一、public修饰的类：

Java笔记_第1张图片
public修饰的类

二、无修饰符(默认包访问权限)的类：

Java笔记_第2张图片
Paste_Image.png

主要区别是对default权限的类，其他包的类根本无法访问到此类，更不用说访问其成员了。

其中，对于一个包里面的包访问权限类A，在其他package的类里面import类A的时候就已经出错了。所以，其他package普通类是根本就访问不了类A，其他package的类也成为不了类A的子孙类。

java泛型

1.使用 通过尖括号来定义 <>
泛型类，接口，<>定义在类名后：

class A {
    
}
class B {
    
}
interface C  {
    
}

泛型方法定义,<>定义在修饰符后，返回值前：

public  void fun(T t) {
    
}

public static  T  fun2() {
    T t = null;
    return t;
}

对定义为 class A {……} 的类，如果定义时 A a = new A();
则T代表的类型使用Object来替代。

泛型类继承：

class A { }
class B extends A { }
class C extends A { }
class D extends A { }

class E extends A { } //编译错误  
//T cannot be resolved to a type

对泛型类传入不同的泛型参数，并不会真正的生成新的类。

List sList = new ArrayList<>();
List iList = new ArrayList<>();
//true
System.out.println(sList.getClass() == iList.getClass());

在静态方法、静态初始化块、或者静态变量不能使用泛型。

instanceof运算符后不能使用泛型运算符

Collection cs = new ArrayList<>();
    
//Cannot perform instanceof check against parameterized type List. 
//Use the form List instead since further generic type information
//will be erased at runtime
//此处编译错误
if (cs instanceof List) {
    
}
//正确的 使用？通配符
if (cs instanceof List) {
    
}

注意Round是Shape的子类，但 List不是List的子类型。

public static void main(String[] args) {
    List list = new ArrayList<>();
    List list2 = new ArrayList<>();
    test(list);
    test(list2);//编译错误
    test2(list2);
}

private static void test(List list) {}
private static void test2(List list) {}

设定通配符的上限：
List，表示可以接收的泛型类型是Shape或者其子类。同时List也是所有Shape泛型List的父类。

public void drawAll(List shapes) {
    for (Shape shape : shapes) {
        shape.draw();
    }
}

但是
public void drawAll(List shapes) {
    for (Shape shape : shapes) {
        shape.draw();
    }
    
    //但是
    shapes.add(new Round());//编译错误
    shapes.add(new Shape());//编译错误
    shapes.add(new Object());//编译错误
    shapes.add(null);//编译正确
}

因为List表示Shape未知的之类，我们无法准确知道这个类型是什么，所以无法将任何对象加到这个集合中。

设定通配符的下限：表示Shape本身，或者是Shape的父类。即介于Object和Shape之间的类。

public void drawAll(List shapes) {
    for (Object shape : shapes) {
        shape.draw();//编译错误 shape没有该方法
    }
    
    //但是
    shapes.add(new Round());
    shapes.add(new Shape());
    shapes.add(new Object());//shape 父类 编译错误
    shapes.add(null);//编译正确
}

因为java的继承是从上往下，父类在最上面，故extends，子类以及本身表示上限，super，本身及其父类，表示下限。

Java 泛型 中 super 怎么 理解？与 extends 有何不同？

// compile error
//    List  appList2 = new ArrayList();
//    appList2.add(new Fruit());
//    appList2.add(new Apple());
//    appList2.add(new RedApple());

List  appList = new ArrayList();
appList.add(new Fruit());
appList.add(new Apple());
appList.add(new RedApple());

首先，泛型的出现时为了安全，所有与泛型相关的异常都应该在编译期间发现，因此为了泛型的绝对安全，java在设计时做了相关的限制：

List表示该list集合中存放的都是E的子类型（包括E自身），由于E的子类型可能有很多，但是我们存放元素时实际上只能存放其中的一种子类型（这是为了泛型安全，因为其会在编译期间生成桥接方法该方法中会出现强制转换，若出现多种子类型，则会强制转换失败），例子如下：

List list=new ArrayList();
    list.add(4.0);//编译错误
    list.add(3);//编译错误

上例中添加的元素类型不止一种，这样编译器强制转换会失败，为了安全，Java只能将其设计成不能添加元素。

虽然List不能添加元素，但是由于其中的元素都有一个共性--有共同的父类，因此我们在获取元素时可以将他们统一强制转换为E类型，我们称之为get原则。

对于List其list中存放的都是E的父类型元素（包括E），我们在向其添加元素时，只能向其添加E的子类型元素（包括E类型），这样在编译期间将其强制转换为E类型时是类型安全的，因此可以添加元素，例子如下：

List list=new ArrayList();
    list.add(2.0);
    list.add(3.0);

但是，由于该集合中的元素都是E的父类型（包括E），其中的元素类型众多，在获取元素时我们无法判断是哪一种类型，故设计成不能获取元素，我们称之为put原则。

实际上，我们采用extends，super来扩展泛型的目的是为了弥补例如List只能存放一种特定类型数据的不足，将其扩展为List 使其可以接收E的子类型中的任何一种类型元素，这样使它的使用范围更广。

List同理。

假设现在有这么一个类的继承树，Plant -> Fruit -> Apple -> RedApple。

List appList2的意思，是一个列表，这个列表里面的元素是Fruit的某个子类T，那么在从appList2中取出一个元素时，编译器会自动把这个元素转型为T。那么现在假设T是RedApple，很显然你往这样一个appList2中add一个Apple类型的元素，取出后转型为RedApple必然会失败；同样的情况如果T是Apple，你add一个Fruit类型的元素，取出后转型为Apple，也会抛出异常。也就是说，编译器会把列表中取出的元素转型为某种类型，但编译器不确定这种转型是不是会成功，即在不保证运行时能顺利进行，因此就不允许你add任何类型的元素。

再来看看List appList，这个列表的元素都是Fruit的父类T，也就是说当你从这个列表中get一个元素时，编译器会自动加一句转型为T的代码。好，现在你往appList中add一个Apple类型的元素，取出时转型为T，由于T是Apple的父类，向上转型没有问题；加一个RedApple类型的元素，也一样不会有问题。也就是说，只要保证你往appList中添加的元素是Fruit的子类，编译器就可以保证在转型为T时不会抛出异常。因此第二种写法可以过编译。

为什么List无法add操作呢，假设Fruit下面还有一个Apple子类，而你的List实例是酱紫的：List list = new ArrayList()，这一刻你终于知道了泛型的具体类型是Apple类。
这样还可以add进Fruit吗？

而List为什么又能add进呢，因为你add进的实例一定会是Fruit及其子类型，而你的List实例的实际泛型参数一定是Fruit及其父类，那么肯定是能add进去的。

关于这两个的使用，假设你是想消费这个List就该用List，因为你可以进行get操作，你可以调用T的接口方法；假设你是想被这个List消费就该用List，因为你可以进行add操作。

java正则表达式的转义字符规则

Java 的正则表达式在匹配点(.) 和斜杠(/)，表达式要分别写作 //. 和 //// ，难看些， 不好理解。幸好还有些人记住了，匹配点(.) 或 {、[、(、?、$、^ 和 * 这些特殊符号要要前加双斜框，匹配 / 时要用四斜杠。

Java定义了一些用来格式化输出的特殊字符。Java使用转义符来表示这些特殊字符，该转义符由一个反斜线（\）和一个随后的助记符组成：

回车            '\r'
换行            '\n'
Tab            '\t'
换页            '\f'
退格            '\b'

由于一对单引号和反斜线对于字符表示有特殊的意义，所以您必须用转义符来表示它们。

单引号        '\'
换码符        '\\'
双引号        '\'''

ThreadLocal

ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。

线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

通过ThreadLocal存取的数据，总是与当前线程相关，也就是说，JVM 为每个运行的线程，绑定了私有的本地实例存取空间，从而为多线程环境常出现的并发访问问题提供了一种隔离机制。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

void set(T value)
将此线程局部变量的当前线程副本中的值设置为指定值。许多应用程序不需要这项功能，它们只依赖于 initialValue() 方法来设置线程局部变量的值。
T get()
返回此线程局部变量的当前线程副本中的值，如果这是线程第一次调用该方法，则创建并初始化此副本。
protected T initialValue()
返回此线程局部变量的当前线程的初始值。最多在每次访问线程来获得每个线程局部变量时调用此方法一次，即线程第一次使用 get() 方法访问变量的时候。如果线程先于 get 方法调用 set(T) 方法，则不会在线程中再调用 initialValue 方法。
void remove()
移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。

在程序中一般都重写initialValue方法，以给定一个特定的初始值。

ThreadLocal使用的一般步骤

1、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间需要隔离处理的对象xxx。
2、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中，通过getXxx()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。

    Integer i=0;
    ThreadLocal local = new ThreadLocal() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            local.set(100);
            while (true) {
                int i = local.get();
                System.out.println("task-1 "+ i);
                i++;
                local.set(i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            local.set(0);
            while (true) {
                int i = local.get();
                System.out.println("task---2 "+ i);
                i++;
                local.set(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
    
    
}

另一个例子

public class ThreadLocalDemo implements Runnable {
    //创建线程局部变量studentLocal，在后面你会发现用来保存Student对象
    private final static ThreadLocal studentLocal = new ThreadLocal<>();
 
    public static void main(String[] agrs) {
        ThreadLocalDemo td = new ThreadLocalDemo();
        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");
        t1.start();
        t2.start();
    }
 
    public void run() {
        accessStudent();
    }
 
    /**
     * 示例业务方法，用来测试
     */
    public void accessStudent() {
        //获取当前线程的名字
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        //产生一个随机数并打印
        Random random = new Random();
        int age = random.nextInt(100);
        System.out.println("thread " + currentThreadName + " set age to:" + age);
        //获取一个Student对象，并将随机数年龄插入到对象属性中
        Student student = getStudent();
        student.setAge(age);
        System.out.println("thread " + currentThreadName + " first read age is:" + student.getAge());
        try {
            Thread.sleep(500);
        }
        catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        student = getStudent();
        System.out.println("thread " + currentThreadName + " second read age is:" + student.getAge());
    }
 
    protected Student getStudent() {
        //获取本地线程变量并强制转换为Student类型
        Student student = studentLocal.get();
        //线程首次执行此方法的时候，studentLocal.get()肯定为null
        if (student == null) {
            System.out.println(Thread.currentThread().getName()+" create");
            //创建一个Student对象，并保存到本地线程变量studentLocal中
            student = new Student();
            studentLocal.set(student);
        }
        return student;
    }
}

class Student {
    private int age = 0;   //年龄
 
    public int getAge() {
        return this.age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。

另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。

通过ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。

如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身，还是有并发访问问题。

wait(),notify()和notifyAll()

wait(),notify()和notifyAll()都是java.lang.Object的方法：

wait(): Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object.

notify(): Wakes up a single thread that is waiting on this object's monitor.

notifyAll(): Wakes up all threads that are waiting on this object's monitor.

使用方法：

To be able to call notify() you need to synchronize on the same object.

synchronized (someObject) {
    someObject.wait();
}

/* different thread / object */
synchronized (someObject) {
    someObject.notify();
}

  1. 要在某个对象上执行wait，notify，先必须锁定该对象

  2. Use the same object for calling wait() and notify() method; every object has its own lock so calling wait() on object A and notify() on object B will not make any sense.

  3. Use notifyAll instead of notify if you expect that more than one thread will be waiting for a lock.

  4. Always call the wait() method in a loop because if multiple threads are waiting for a lock and one of them got the lock and reset the condition, then the other threads need to check the condition after they wake up to see whether they need to wait again or can start processing.

     public static void main(String[] args) throws InterruptedException {
     Object obj = new Object();
     obj.wait();
     obj.notifyAll();
 }

 public static void main(String[] args) throws InterruptedException {
     Object obj = new Object();
     Object lock = new Object();
     synchronized (lock) {
         obj.wait();
         obj.notifyAll();
     }
 }

执行以上代码，会抛出java.lang.IllegalMonitorStateException的异常。

注意对区块内的局部变量，只能使用final修饰符，不能使用static或者volatile.

Java笔记_第3张图片
only final is permitted

匿名内部类的原理：
匿名类的参考：
http://liuzxc.github.io/blog/java-advance-02/
http://www.cnblogs.com/chenssy/p/3390871.html

public class ThreadPool {
    public static void main(String[] args)  {
        new Bird().fly();
        new Bird() {//匿名内部类
            String getName() {
                return "bird";
            };
        }.fly();
    }
}

class Bird {
    String name;
    void fly() {
        System.out.println(getName() + " fly");
    }
    String getName() {
        return name;
    }
}

输出：
null fly
bird fly

上述匿名内部类的代码相当于：

Java笔记_第4张图片
Paste_Image.png

内部类可以自由访问外部类的成员，因为内部类本身就是外部类的成员。但内部类访问外部类的局部变量时候却是有限制的，即不能直接修改外部类的局部变量，并要求局部变量是final类型的。

Java笔记_第5张图片
可以访问a.png
Java笔记_第6张图片
编译不通过.png

你可能感兴趣的:(Java笔记)

  • effective java笔记 Mrryo
    1、Java中创建（实例化）对象的五种方式：a、new一个对象。b、反射，Objecta=Class.forName("java.lang.Object").newInstance();c、通过I/O流(包括反序列化)。d、对象的clone()。e、通过工厂方法返回对象。2、抽象类，要想对其实例化，只能用getInstance().(单例模式)。3、内存泄漏：用数组、集合、缓存、监听器等时要注意释
  • java笔记--构造函数 吃饱喝足搬代码丶
    特点：1函数名与类名相同2不用定义返回值类型3没有具体的返回值作用：给对象进行初始化注意：1默认构造函数的特点2多个构造函数是以重载的形式（方法名相同，参数列表不一样）存在的定义一个Person类：classPerson{privateStringname;privateintage;//这里主要讲构造函数，忽略getter和setter//定义一个Person类的构造函数Person(){//构
  • MySQL高级篇——排序、分组、分页优化 程序员小海绵【vincewm】 Java学习路线数据库sqljava
    导航：【Java笔记+踩坑汇总】Java基础+进阶+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud+黑马旅游+谷粒商城+学成在线+MySQL高级篇+设计模式+牛客面试题目录5.排序优化5.1排序优化建议5.2测试5.2.1案例验证5.3.2练习5.3范围查询时索引字段选择5.4filesort算法5.4.1双路排序和单路排序5.4.2调优filesort6.分组优化
  • Java笔记 迭代器Itr blossom_6694
    1、Itr是AbstractList里面的一个内部类,实现了Iterator接口。publicIteratoriterator(){returnnewItr();}2、分析Itr。privateclassItrimplementsIterator{//下一个元素的索引位置intcursor=0;//lastRet表示上一个元素的索引位置,如果执行了remove操作会置为-1intlastRet=-
  • 【我与Java的成长记】之多态，重载与重写详解 古德猫宁- Java笔记java开发语言经验分享笔记学习
    系列文章目录能看懂文字就能明白系列C语言笔记传送门Java笔记传送门个人主页：古德猫宁-信念如阳光，照亮前行的每一步文章目录系列文章目录*信念如阳光，照亮前行的每一步*前言一、多态的概念二、多态的实现条件三、补充：重载与重写重载的概念重载的例子重载的规则重写的概念重写的例子重写的规则重载与重写的区别四、向上转型和向下转型向上转型向下转型多态的优缺点前言本节目标：理解多态的思想，掌握多态的使用，理解
  • 【我与Java的成长记】之String类详解 古德猫宁- Java笔记java开发语言学习笔记经验分享
    系列文章目录能看懂文字就能明白系列C语言笔记传送门Java笔记传送门个人主页：古德猫宁-信念如阳光，照亮前行的每一步文章目录系列文章目录*信念如阳光，照亮前行的每一步*前言一、字符串构造二、String类的特性三、StringBuilder和StringBuffer总结三、StringBuilder一些常见的方法前言String类是Java中用于表示字符串的核心类之一。它提供了丰富的方法来操作字符
  • Java笔记 --- 六、IO流 Marchwho java笔记idea
    六、IO流概述分类纯文本文件：Windows自带的记事本打开能读懂的eg：txt文件，md文件，xml文件，lrc文件IO流体系字节流FileOutputStream操作本地文件的字节输出流，可以把程序中的数据写到本地文件中创建字节输出流对象写数据释放资源写数据的3种方式FileInputStream操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中创建字节输入流对象读数据释放资源循环读
  • Java笔记 --- 七、多线程 Marchwho java笔记idea
    七、多线程线程线程是操作系统能够运行调度的最小单位被包含在进程之中，是进程的实际运行单位应用软件中相互独立，可以同时运行的功能每一个线程都有自己的栈并发和并行并发：在同一时刻，有多个指令在单个CPU上交替执行并行：在同一时刻，有多个指令在多个CPU上同时执行多线程的实现方式继承Thread类定义一个类继承Thread重写run方法创建类的对象，调用start()方法开启线程实现Runnable接口
  • 【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版） 程序员小海绵【vincewm】 Java面试题汇总Java学习路线jvmjava开发语言
    导航：【黑马Java笔记+踩坑汇总】JavaSE+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud+黑马旅游+谷粒商城+学成在线+设计模式+牛客面试题目录三、String3.1.String常量池3.2.请你说说String类3.3.newString("abc")创建了几个字符串对象？3.4.String、StringBuffer、Stringbuilder有什么区
  • java该怎么做笔记_java学习笔记整理，如何整理java笔记？ 不拾掇能这样吗 java该怎么做笔记
    俗话说：“好记性不如烂笔头”，不得不说，这句话在大部分时候都是适用的。特别是刚刚入门学习java的朋友，是不是也觉得整理学习笔记是一件麻烦的事?下面就带大家来看看到底应该如何整理java笔记比较好呢?学习笔记切记过于复杂冗余，简单明了为上，可以选择一款比较方便的专门记录学习笔记的App，分门别类的记录为上。示例目录：基本概念篇操作系统中heap和stack的区别1.什么是基于注解的切面实现2.什么
  • Java 学习和实践笔记（1） 复业思维20240108 学习笔记java
    2024年，决定好好学习计算机语言Java.B站上选了这个课程：【整整300集】浙大大佬160小时讲完的Java教程（学习路线+Java笔记）零基础，就从今天开始学吧。在这些语言中，C语言是最基础的语言，绝大多数语言的底层都是基于C来扩展的。C是面向过程的语言。C++是基于C而扩展成的面向对象语言。Java是在C++基础上做了优化，减少了一些复杂性，又称为C++-.Javascript与Java，
  • Java笔记01 大萌光武帝
    系统软件：win7、Linux应用软件：qq、微信应用软件运行在系统软件上主要开发系统软件Windows的dos命令：1.cls2.exit3右键标记4.cd5.切换盘符C:D:E:文件扩展名——》组织——》文件夹和搜索选项——》查看机器语言低级语言高级语言javase是基础javaee是大方向可面向对象可移植性健壮性简单性多线程java系统不能和操作系统直接打交道编译过程：编译java源文件需要
  • 【Think In Java笔记】第1章 对象导论 weixin_30703911 java
    1.对象导论OOP面向对象编程C、Basic等语言所在的抽象仍要求在解决问题时基于计算机的解决，而不是基于所解决问题的结构来考虑。要建立起问题空间的元素和解空间的对象之间一一映射的关系万物皆对象；程序是对象的集合每个对象都提供服务当正在试图开发或者理解一个程序设计时，最好的方法之一就是将对象想象成“服务提供者”。程序本身将向用户提供服务，它将通过调用其他对象提供的服务来实现这一目的。被隐藏的具体实
  • java listiterator_Java笔记--Java的List、Iterator用法 衣锦夜行的李公子 javalistiterator
    1.List的使用准备知识：List继承自Collection接口。List是一种有序集合，List中的元素可以根据索引(顺序号：元素在集合中处于的位置信息)进行取得/删除/插入操作。跟Set集合不同的是，List允许有重复元素。对于满足e1.equals(e2)条件的e1与e2对象元素，可以同时存在于List集合中。当然，也有List的实现类不允许重复元素的存在。List还提供一个listIte
  • Java笔记(网络编程、正则表达式) 独行乡窝窝侠 java笔记
    一、网络编程1.网络协议(TCP/IP)1.1.概述传输层协议中有两个非常重要的协议：传输控制协议TCP(TransmissionControlProtocol)用户数据报协议UDP(UserDatagramProtocol)**TCP/IP以其两个主要协议：传输控制协议(TCP)和网络互联协议(IP)**而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。IP(InternetPro
  • JAVA笔记5 Lucky_Husky java笔记开发语言
    Java语法基础1.标识符：用来标识类名、对象名、变量名、方法名、类型名、数组名、文件名的有效字符序列。2.合法的标识符：由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且首字符不能是数字。不能把java关键字和保留字作为标识符。标识符对大小写敏感。关键字：Java语言中已经赋予了特定含义的3.变量：程序运行期间可以被改变的量。在程序中使用变量，必须先创建它并为它取一个名字，并且指明它
  • Java笔记：成员变量，局部变量，类变量，实例变量以及注意事项 哦00
    局部变量：方法中定义的变量。成员变量（类似C中的全局变量）：成员变量定义在方法体和语句块之外。成员变量就概括描述了类中的变量，不区分static。是以下变量的统称。类变量（静态变量）：独立于方法之外的变量，属于类本身。需要static修饰，事实上，类变量就是以static修饰的独立于方法之外的成员变量。类变量必须在方法、构造方法和语句块之外。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。实
  • Java笔记 --- 一、双列集合 Marchwho javaidea笔记
    一、双列集合双列集合的特点Map创建Map对象时，要规定键和值的泛型Map是一个接口，不能直接创建，要创建实例化对象Map的遍历通过键找值先获取到键的对象，并放到一个单列集合中（map.KeySet()方法）遍历通过键调用get()方法获取到值遍历可以用增强for，迭代器，Lambda表达式(forEach())键值对（forEach的底层原理）通过调用map.entrySet()把键值对放到一个
  • Java笔记 --- 五、File Marchwho javaidea笔记
    五、File概述将字符串变成File对象，再去使用里面的方法父级路径：除了文件本身的路径C:\Users\Desktop子级路径：文件名m.txt常见的成员方法判断、返回length只能获取文件的大小(字节数量)创建、删除delete方法默认只能删除文件和空文件夹delete方法直接删除，不走回收站获取并遍历套路进入文件夹遍历数组判断判断
  • Java笔记 --- 二、Stream流 Marchwho javaidea笔记
    二、Stream流结合Lambda表达式，简化集合、数组的操作获取Stream流对象单列集合获取Stream流双列集合获取Stream流数组获取Stream流一堆零散的数据获取Stream流Stream流的静态方法of的形参是一个可变参数，可以传递零散数据，也可以传递数组但是数组必须是引用数据类型Stream流的中间方法Stream流的终结方法收集方法可以放到（list，Set，Map）中
  • Java笔记 --- 三、方法引用 Marchwho java笔记idea
    三、方法引用概述分类引用静态方法引用成员方法本类中注意，静态方法中没有this，需要创建本类的对象引用构造方法其他的调用方式使用类名引用成员方法引用数组的构造方法
  • Java笔记 --- 四、异常 Marchwho java笔记开发语言
    四、异常Java.lang.ThrowableErrorException（异常）异常的作用异常的处理方式JVM默认的处理方式捕获异常（自己处理）try里面没有出现异常，就不会运行catch里面的代码如果出现多个异常，需要多个catch要处理异常（如果异常存在父子关系，父类应该写在最下面）在JDK7以后，可以在catch中同时捕获多个异常，中间用|隔开，采取同一种方案如果try中没有捕获到，采用虚
  • Java笔记(多线程) 独行乡窝窝侠 java笔记
    文章目录一、多线程1.程序，进程，线程2.并行和并发3.单核CPU和多核CPU4.多线程优缺点和应用场景5.线程创建5.1.Thread5.2.Runnable5.3.继承和实现的区别6.优先级和常用方法6.1.优先级概述6.2.常用方法6.3.使用方式7.生命周期8.线程控制8.1.线程停止8.2.线程合并8.3.Yield9.线程同步9.1.概述9.2.不同步带来的问题9.3.解决方案9.3.
  • Java笔记(数据流、File、对象流) 独行乡窝窝侠 java笔记
    文章目录一、数据流1.概述2.使用二、File1.概述2.构造方法3.常用方法4.使用方式5.递归复制三、对象流1.概述2.注意3.序列化4.反序列化5.serialVersionUID6.Transient一、数据流1.概述数据流：为了方便操作java中的基本类型和字符串类型数据，可以使用数据流来进行操作以二进制形式进行数据传递，并且读写顺序及类型必须一致，常用于网络数据传递2.使用写入try(
  • Java笔记(集合、散列表、Map、泛型) 独行乡窝窝侠 java笔记
    一、集合1.Set和排序set：无序不可重复无序：不保证有序，就是有可能有序，有可能无序不可重复：不能添加重复数据HashSetTreeSet：底层是红黑树，会自动排序，意味着里面存储的必须是同类型的元素对象数字：从小到大排序字符串：一次比较每一位的ascll码值日期：自然日期顺序1.1.TreeSetpublicclassCollection_01_TreeSet{publicstaticvoi
  • Java笔记(IO流) 独行乡窝窝侠 java笔记
    一、IO1.概述流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作input：输入ouput：输出2.分类按数据处理类型的不同，分为字节流和字符流按数据流向的不同，分为输入流和输出流。(入和出是相对于内存来讲的)按功能不同，分为节点流和处理流节点流：直接操作数据源处理流：对
  • java笔记（String、StringBuffer、包装类） 独行乡窝窝侠 java笔记
    一、String1.概述java.lang.String字符串类底层是一个字符数组，所以他的很多特性就是数组则特性字符串与一旦确定，不能修改为了提高字符串效率，java虚拟机使用了一种"缓存技术"，字符串常量池创建一个字符串对象的时候，先查看字符串常量池中有没有该字符串对象如果没有就创建一个，如果有就直接指向该对象有时候字符串类型可以用==进行比较，是因为他们的内存地址一样（仅限字面量），数字或字
  • java笔记（类之间关系、内部类、设计模式） 独行乡窝窝侠 java笔记
    一、类之间关系1.继承//类和类之间是单继承classAextendsCode{}interfaceB{}interfaceC{}//接口和接口之间是继承,多继承用逗号隔开interfaceDextendsB,C{}2.实现//类和接口之间是实现,多个实现用逗号隔开classEimplementsB,C{}3.依赖//局部变量保存的是其他类的引用//依赖关系Aa=newA();//类和类之间是单继
  • Java笔记（数据类型，变量，运算符） 独行乡窝窝侠 java笔记
    1.数据类型分为：（1）基本数据类型数值型整数byte字节8bit-128~127short短整型16bit-32768~32767int整形32bit-2147483648~2147483647long长整型64bit小数（浮点数）字符型char16bit无符号位布尔型boolean8bittrue/false（2）引用数据类型类，数组，接口2.进制二进制（0b开头）八进制（以0开头），十进制，
  • Java笔记(死锁、线程通信、单例模式) 独行乡窝窝侠 java笔记
    一、死锁1.概述死锁:死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法往下执行。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程原理:某个线程执行完成,需要先后嵌套锁定两个对象,在这个过程中,先锁定了第一个对象另一个线程执行完成也需要先后嵌套锁定两个对象,在这个过程中,先锁定了第二个对象第一个线程执
  • apache ftpserver-CentOS config gengzg apache
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://mina.apache.o
  • 优化MySQL数据库性能的八种方法 AILIKES sqlmysql
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
  • JeeSite 企业信息化快速开发平台 Kai_Ge JeeSite
    JeeSite 企业信息化快速开发平台 平台简介 JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
  • 通过Spring Mail Api发送邮件 120153216 邮件main
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 Spring Mail API都在org.spri
  • Pysvn 程序员使用指南 2002wmj SVN
    源文件:http://ju.outofmemory.cn/entry/35762 这是一篇关于pysvn模块的指南. 完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 该
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL 357029540 SQL Server
    SELECT  R.session_id AS BlockedSessionID ,          S.session_id AS BlockingSessionID ,          Q1.text AS Block
  • Intent 常用的用法备忘 7454103 .netandroidGoogleBlogF#
    Intent     应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 下面列出几种Intent 的用法 显示网页:
  • Spring定时器时间配置 adminjun spring时间配置定时器
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 测试的时候，由于是每天定时执行，所以后面三个数
  • POJ 2421 Constructing Roads 最小生成树 aijuans 最小生成树
    来源：http://poj.org/problem?id=2421 题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 代码： #include <iostream> #include <cstdio>
  • 重构笔记——提取方法（Extract Method） ayaoxinchao java重构提炼函数局部变量提取方法
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。   下面是我学习这个重构手法的笔记：   提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
  • 为UILabel添加点击事件 bewithme UILabel
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。   UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例) bijian1013 redis数据库NoSQL
    一.redis.php <?php //实例化 $redis = new Redis(); //连接服务器 $redis->connect("localhost"); //授权 $redis->auth("lamplijie"); //相关操
  • SecureCRT使用备注 bingyingao secureCRT每页行数
    SecureCRT日志和卷屏行数设置 一、使用securecrt时，设置自动日志记录功能。 1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 2、点击Options -> Global Options -> Default Session -> Edite Default Sett
  • 【Scala九】Scala核心三：泛型 bit1129 scala
    泛型类 package spark.examples.scala.generics class GenericClass[K, V](val k: K, val v: V) { def print() { println(k + "," + v) } } object GenericClass { def main(args: Arr
  • 素数与音乐 bookjovi 素数数学haskell
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。     闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
  • Java-Collections Framework学习与总结-IdentityHashMap BrokenDreams Collections
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。         简单的说，IdentityHashMap和HashM
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java
  • PS人像润饰&调色教程集锦 cherishLC PS
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 http://www.howzhi.com/course/retouching/   新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。   所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
  • 更新多个字段的UPDATE语句 crabdave update
    更新多个字段的UPDATE语句                    update tableA a set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围
  • hive实例讲解实现in和not in子句 daizj hivenot inin
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
  • 一道24点的10+种非人类解法（2,3,10,10） dsjt 算法
    这是人类算24点的方法？！！！ 事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 然后么。。。我就在深夜很得瑟的问室友求室友算 刚出完题，文哥的暴走之旅开始了 5秒后
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题 dcj3sjt126com yiiframework
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
  • 对象与关系之间的矛盾：“阻抗失配”效应[转] come_for_dream 对象
    概述   “阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。   “阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
  • 学习编程那点事 gcq511120594 编程互联网
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
  • Reverse Linked List II hcx2013 list
    Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • Hadoop集群工具distcp liyonghui160com
        1. 环境描述 两个集群：rock 和 stone rock无kerberos权限认证，stone有要求认证。 1. 从rock复制到stone，采用hdfs Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
  • 一个备份MySQL数据库的简单Shell脚本 pda158 mysql脚本
    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份 数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　 1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇 shoothao IT资源图标库图片库色彩板字体
    A. 免费的设计资源 Freebbble:来自于Dribbble的免费的高质量作品。 Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 Pixel Buddha:免费和优质资源的专业社区。 Premium Pixels:为那些有创意的人提供免费的素材。
  • thrift总结 - 跨语言服务开发 uule thrift
    官网 官网JAVA例子 thrift入门介绍 IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 Thrift入门及Java实例演示 thrift的使用介绍   RPC    POM： <dependency> <groupId>org.apache.thrift</groupId>
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他