JavaSE
对象
《Java编程思想》中的一段原话:
“按照通俗的说法,每个对象都是某个类(class)的一个实例(instance),这里,‘类’就是‘类型’的同义词。”
简而言之,它就是类的实例
创建对象
Java中有5种创建对象的方式,下面给出它们的例子还有它们的字节码
使用new关键字 } → 调用了构造函数
使用Class类的newInstance方法 } → 调用了构造函数
使用Constructor类的newInstance方法 } → 调用了构造函数
使用clone方法 } → 没有调用构造函数
使用反序列化 } → 没有调用构造函数
如果你运行了末尾的的程序,你会发现方法1,2,3用构造函数创建对象,方法4,5没有调用构造函数。
1.使用new关键字
这是最常见也是最简单的创建对象的方式了。通过这种方式,我们可以调用任意的构造函数(无参的和带参数的)。
Employee emp1 = new Employee();
2.使用Class类的newInstance方法
我们也可以使用Class类的newInstance方法创建对象。这个newInstance方法调用无参的构造函数创建对象。
我们可以通过下面方式调用newInstance方法创建对象:
Employee emp2 = (Employee) Class.forName(“org.programming.mitra.exercises.Employee”).newInstance();
或者
Employee emp2 = Employee.class.newInstance();
3.使用Constructor类的newInstance方法
和Class类的newInstance方法很像, java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。
Constructor constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();
这两种newInstance方法就是大家所说的反射。事实上Class的newInstance方法内部调用Constructor的newInstance方法。这也是众多框架,如Spring、Hibernate、Struts等使用后者的原因。
4.使用clone方法
无论何时我们调用一个对象的clone方法,jvm就会创建一个新的对象,将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。
要使用clone方法,我们需要先实现Cloneable接口并实现其定义的clone方法。
Employee emp4 = (Employee) emp3.clone();
5.使用反序列化
当我们序列化和反序列化一个对象,jvm会给我们创建一个单独的对象。在反序列化时,jvm创建对象并不会调用任何构造函数。
为了反序列化一个对象,我们需要让我们的类实现Serializable接口
ObjectInputStream in = new ObjectInputStream(new FileInputStream(“data.obj”));
Employee emp5 = (Employee) in.readObject();
我们从上面的字节码片段可以看到,除了第1个方法,其他4个方法全都转变为invokevirtual(创建对象的直接方法),第一个方法转变为两个调用,new和invokespecial(构造函数调用)。
集合
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection
List
List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
LinkedList
LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
List list = Collections.synchronizedList(new LinkedList(…));
迭代器Iterator:
LinkedList没有实现List接口中的iterator方法,但是为什么创建LinkedList对象是还可以用iterator,因为LinkedList继承了AbstractSequentialList方法,AbstractSequentialList继承了AbstractList方法,AbstractList方法实现了List接口,并实现了iterator
LinkedList中还有通过集成获得的listIterator()方法,该方法只是调用了listIterator(int index)并且传入0。
该方法只是简单的返回了一个ListItr对象。
下面详细分析ListItr。
ArrayList
ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法 并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
ArrayList方法中的属性:
//设置arrayList默认容量
private static final int DEFAULT_CAPACITY = 10;
//空数组,当调用无参数构造函数的时候默认给个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//这才是真正保存数据的数组
private transient Object[] elementData;
//arrayList的实际元素数量
private int size;
将提供的集合转成数组返回给elementData(返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[])
动态扩展
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//设置新数组的容量扩展为原来数组的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//再判断一下新数组的容量够不够,够了就直接使用这个长度创建新数组,不够就将数组长度设置为需要的长度
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//判断有没超过最大限制
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//将原来数组的值copy新数组中去, ArrayList的引用指向新数组
//这儿会新创建数组,如果数据量很大,重复的创建的数组,那么还是会影响效率,因此鼓励在合适的时候通过构造方法指定默认的capaticy大小
elementData = Arrays.copyOf(elementData, newCapacity);
}
迭代器Iterator:
(1) 属性
a 游标
int cursor; 我们知道iterator是始终向前走的,就是这个游标始终在++的原因
b 末尾标识
int lastRe 标识了最后一个返回的元素的索引位置,-1代表这个元素不存在
C 操作数标识
int expectedModCount = modCount; 这个非常重要,它用来校验在使用iterator期间,是否存在非Iterator的操作对ArrayList进行了修改。
(2)checkForComodification
这个方法很简单,但是可以看到在这个内部类中,几乎所有方法都在调用它。它所做的工作就是校验在使用iterator期间,是否存在非Iterator的操作对ArrayList进行了修改。
在ArrayList中,有很多操作都修改了一个变量,modCount。每次进行操作,modCount都在++。前面一直不理解这个有什么用,在这看到了它的用意。Iterator的游标特性决定了它对ArrayList中元素在这一时刻的位置很敏感,如果当前游标在index位置,而有其他操作在index-1的位置上插入了一个元素,那么调用iterator的next()方法,返回的还是当前这个元素,这样就乱了。为了避免这个情况发生,需要在这个期间把ArrayList“锁住“。它并没有实现真正的锁,所以采用了这个校验的方式。
(3)next()
返回当前游标位置的元素,这里面第一个if判断的条件很有意思。因此游标前移,当移动到一个不存在数据的地方,它抛出了异常。而并没有返回null。这就是我们为什么在使用iterator的时候不能用(null==iterator.next())来判断的原因。而是在要每次循环开始的时候判断iterator.hasNext()。
(4) remove()
删除lastRe 所标识位置的元素。我们可以把它理解为当前元素。在try前面有一个校验,保证元素没有被改动过,要不就删错了。
在try{}语句块中,首先删除了lastRe标识的元素,然后让游标指向了这个位置。我们知道在删除元素以后,这个位置有了新的元素,这样再次调用next()的时候不会出现空指针异常,更不会跳过一个元素。
最后expectedModCount = modCount;这句相当于释放了锁。也是在表示,在我Iterator的地盘,只有我能够去修改mod,别人动了就不行!
ListIterator:
无参,返回一个ListIterator对象,ListItr为ArrayList的一个内部类,其实现了ListIterator 接口
有参,返回一个从index开始的ListIterator对象
Vector
Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和 ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了 Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出 ConcurrentModificationException,因此必须捕获该异常。
Stack
Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set
Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。
Set s = new HashSet();
hashset 底层 是用的hashmap来存储数据的,set元素的值 存放在hashmap的key中,value中存放了一个模拟值 PERSENT。
我们都知道 hashmap中的key是不能重复的,所以hashset就利用这个特性实现了 set中的值不会重复。
HashMap中的哈希算法
对于HashSet而言,它是基于HashMap实现的,HashSet底层使用HashMap来保存所有元素,因此HashSet 的实现比较简单,相关HashSet的操作,基本上都是直接调用底层HashMap的相关方法来完成
Map
HashMap
HashMap中定义的属性
HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap 的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。
初始化hashmap
当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小为16,那么当HashMap中元素个数超过160.75=12(这个值就是代码中的threshold值,也叫做临界值)的时候,就把数组的大小扩展为 2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。
HashMap数组扩容
- void resize(int newCapacity) { //传入新的容量
-
Entry[] oldTable = table; //引用扩容前的Entry数组
-
int oldCapacity = oldTable.length;
-
if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
-
threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
-
return;
-
}
-
Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
-
transfer(newTable); //!!将数据转移到新的Entry数组里
-
table = newTable; //HashMap的table属性引用新的Entry数组
-
threshold = (int) (newCapacity * loadFactor);//修改阈值
- }
这里就是使用一个容量更大的数组来代替已有的容量小的数组,transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。 - void transfer(Entry[] newTable) {
-
Entry[] src = table; //src引用了旧的Entry数组
-
int newCapacity = newTable.length;
-
for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
-
Entry<K, V> e = src[j]; //取得旧Entry数组的每个元素
-
if (e != null) {
-
src[j] = null;//释放旧Entry数组的对象引用(for循环后,旧的Entry数组不再引用任何对象)
-
do {
-
Entry<K, V> next = e.next;
-
int i = indexFor(e.hash, newCapacity); //!!重新计算每个元素在数组中的位置
-
e.next = newTable[i]; //标记[1]
-
newTable[i] = e; //将元素放在数组上
-
e = next; //访问下一个Entry链上的元素
-
} while (e != null);
-
}
-
}
- }
- static int indexFor(int h, int length) {
-
return h & (length - 1);
- }
Hashtable
Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大,这会影响像get和put这样的操作。
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相 同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如 果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希 表的操作。
如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
Hashtable是同步的。
成员变量:
初始化HashTable
HashMap的put
HashTable的同步put
WeakHashMap
WeakHashMap是一种改进的HashMap,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。
线程
线程声明周期:
Java线程具有五中基本状态
新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;
运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同,阻塞状态又可以分为三种:
1.等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
Java多线程的创建及启动
1.继承Thread类,重写该类的run()方法。
例:
class MyThread extends Thread{};
Thread myThread = new MyThread();
重写run()方法
myThread.start();
Thread启动后执行run()方法
Thread.currentThread().getName()方法获取当前线程名称
2.实现Runnable接口,并重写该接口的run()方法
例:
class MyRunnable implements Runnable{}
Thread myRunnable = new Thread(new MyRunnable);
myRunnable.start();
Thread启动后执行run()方法
Thread.currentThread().getName()方法获取当前线程名称
3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类,并实现clall()方法。
Runnable接口
Thread类
初始化thread
Thread类中常用方法
start
start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。
run
run()方法是不需要用户来调用的,当通过start方法启动一个线程之后,当线程获得了CPU执行时间,便进入run方法体去执行具体的任务。注意,继承Thread类必须重写run方法,在run方法中定义具体要执行的任务。
sleep
sleep(long millis) //参数为毫秒
sleep(long millis,int nanoseconds) //第一参数为毫秒,第二个参数为纳秒
sleep相当于让线程睡眠,交出CPU,让CPU去执行其他的任务。
但是有一点要非常注意,sleep方法不会释放锁,也就是说如果当前线程持有对某个对象的锁,则即使调用sleep方法,其他线程也无法访问这个对象。
yield
调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
注意,调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的。
Join
中断其它线程的执行,等待调用join方法的线程结束,即使是主线程main也会被中断。
join()
join(long millis) //参数为毫秒
join(long millis,int nanoseconds) //第一参数为毫秒,第二个参数为纳秒
Callable接口
RunnableFuture接口
线程同步:
线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏。
1)、只能同步方法,而不能同步变量和类;
2)、每个对象只有一个锁;当提到同步时,应该清楚在什么上同步。也就是说,在哪个对象上同步。
3)、不必同步类中所有的方法,类可以同时拥有同步和非同步方法。
4)、如果两个线程要执行一个类中的synchronized方法,并且两个线程使用相同的实例来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。也就是说:如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。
5)、如果线程拥有同步和非同步方法,则非同步方法可以被多个线程自由访问而不受锁的限制。
6)、线程睡眠时,它所持的任何锁都不会释放。
7)、线程可以获得多个锁。比如,在一个对象的同步方法里面调用另外一个对象的同步方法,则获取了两个对象的同步锁。
8)、同步损害并发性,应该尽可能缩小同步范围。同步不但可以同步整个方法,还可以同步方法中一部分代码块。
9)、在使用同步代码块时候,应该指定在哪个对象上同步,也就是说要获取哪个对象的锁。
锁:
Synchronized
Java关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。(synchronized锁定所有的同步代码块,一旦阻塞,所有同步代码块都被阻塞)
四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。(synchronized获取整个对象的锁,整个对象将被锁定)
五、以上规则对其它对象锁同样适用.
修饰方法
此方法同一时间只允许一个线程访问,在线程执行完成后,释放锁之后,才允许访问
- public synchronized void doSomething(){}
修饰代码块 - public void increaseAmt(float increaseAmt){
-
try {
-
TimeUnit.SECONDS.sleep(1);
-
} catch (InterruptedException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
-
synchronized (this) {
-
System.out.println(this);
-
amt+=increaseAmt;
-
}
-
}
修饰方法
- public synchronized static void increaseAmt(float increaseAmt){
-
try {
-
TimeUnit.SECONDS.sleep(1);
-
} catch (InterruptedException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
-
amt+=increaseAmt;
-
}
修饰类
- synchronized (AccountSynchronizedClass.class) {
-
amt-=decreaseAmt;
-
}
Locked接口
Lock和synchronized有以下几点不同
1)Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现;
2)synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁;
3)Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断;
4)通过Lock可以知道有没有成功获取锁,而synchronized却无法办到。
5)Lock可以提高多个线程进行读操作的效率。
在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈时(即有大量线程同时竞争),此时Lock的性能要远远优于synchronized。所以说,在具体使用时要根据适当情况选择。
Lock的操作与synchronized相比,灵活性更高,而且Lock提供多种方式获取锁,有Lock、ReadWriteLock接口,以及实现这两个接口的ReentrantLock类、ReentrantReadWriteLock类。
案例:
- public class LockImp {
-
private Lock lock=new ReentrantLock();
-
private ReadWriteLock rwLock=new ReentrantReadWriteLock();
-
private List<Integer> list=new ArrayList<Integer>();
-
public void doReentrantLock(Thread thread){
-
lock.lock();
-
System.out.println(thread.getName()+"获取锁");
-
try {
-
for(int i=0;i<10;i++){
-
list.add(i);
-
}
-
} catch (Exception e) {
-
}finally{
-
lock.unlock();
-
System.out.println(thread.getName()+"释放锁");
-
}
-
}
-
public void doReentrantReadLock(Thread thread){
-
rwLock.readLock().lock();
-
System.out.println(thread.getName()+"获取读锁");
-
try {
-
for(int i=0;i<10;i++){
-
list.add(i);
-
}
-
} catch (Exception e) {
-
}finally{
-
rwLock.readLock().unlock();
-
System.out.println(thread.getName()+"释放读锁");
-
}
-
}
-
public void doReentrantWriteLock(Thread thread){
-
rwLock.writeLock().lock();
-
System.out.println(thread.getName()+"获取写锁");
-
try {
-
for(int i=0;i<10;i++){
-
list.add(i);
-
}
-
} catch (Exception e) {
-
}finally{
-
rwLock.writeLock().unlock();
-
System.out.println(thread.getName()+"释放写锁");
-
}
-
}
-
/**
-
* @param args
-
*/
-
public static void main(String[] args) {
-
final LockImp lockImp=new LockImp();
-
final Thread thread1=new Thread();
-
final Thread thread2=new Thread();
-
final Thread thread3=new Thread();
-
new Thread(new Runnable() {
-
@Override
-
public void run() {
-
lockImp.doReentrantLock(thread1);
-
}
-
}).start();
-
new Thread(new Runnable() {
-
@Override
-
public void run() {
-
lockImp.doReentrantLock(thread2);
-
}
-
}).start();
-
new Thread(new Runnable() {
-
@Override
-
public void run() {
-
lockImp.doReentrantLock(thread3);
-
}
-
}).start();
-
lockImp.doReentrantReadLock(thread1);
-
lockImp.doReentrantReadLock(thread2);
-
lockImp.doReentrantReadLock(thread3);
-
lockImp.doReentrantWriteLock(thread1);
-
lockImp.doReentrantWriteLock(thread2);
-
lockImp.doReentrantWriteLock(thread3);
-
}
- }
线程池:
线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。
常用线程池
newCachedThreadPool(可缓存线程池)
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
这种类型的线程池特点是:
工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务,即如果工作线程空闲了指定的时间(默认为1分钟),则该工作线程将自动终止。终止后,如果你又提交了新的任务,则线程池重新创建一个工作线程。
在使用CachedThreadPool时,一定要注意控制任务的数量,否则,由于大量线程同时运行,很有会造成系统瘫痪。
实例:
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}
newFixedThreadPool(指定工作线程数量的线程池)
创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。
FixedThreadPool是一个典型且优秀的线程池,它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是,在线程池空闲时,即线程池中没有可运行任务时,它不会释放工作线程,还会占用一定的系统资源。
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
newSingleThreadExecutor(单线程化的线程池)
创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束,会有另一个取代它,保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
newScheduleThreadPool(定长的线程池)
创建一个定长的线程池,而且支持定时的以及周期性的任务执行,支持定时及周期性任务执行。
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println(“delay 3 seconds”);
}
}, 3, TimeUnit.SECONDS);
}
}
IO和NIO
IO
字符流:一次读入或读出是16位二进制。
字节流:一次读入或读出是8位二进制。
对文件进行操作:FileInputStream(字节输入流),FileOutputStream(字节输出流),FileReader(字符输入流),FileWriter(字符输出流)
对管道进行操作:PipedInputStream(字节输入流),PipedOutStream(字节输出流),PipedReader(字符输入流),PipedWriter(字符输出流)
PipedInputStream的一个实例要和PipedOutputStream的一个实例共同使用,共同完成管道的读取写入操作。主要用于线程操作。
字节/字符数组:ByteArrayInputStream,ByteArrayOutputStream,CharArrayReader,CharArrayWriter是在内存中开辟了一个字节或字符数组。
Buffered缓冲流:BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter,是带缓冲区的处理流,缓冲区的作用的主要目的是:避免每次和硬盘打交道,提高数据访问的效率。
转化流:InputStreamReader,OutputStreamWriter,把字节转化成字符。
数据流:DataInputStream,DataOutputStream。
打印流:printStream,printWriter,一般是打印到控制台,可以进行控制打印的地方。
对象流:ObjectInputStream,ObjectOutputStream,把封装的对象直接输出,而不是一个个在转换成字符串再输出。
序列化流:SequenceInputStream
回退流:PushBuckInputStream
例:
DataInputStream di = new DataInputStream(
new BufferedInputStream(
new FileInputStream(“C:\Users\can\Desktop\sql.txt”)));
DataOutputStream dop = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(“C:\Users\can\Desktop\1.txt”)));
NIO
Java NIO 核心部分组成:
Channels:通道
FileChannel:从文件中读写数据。
DatagramChannel:能通过UDP读写网络中的数据。
SocketChannel:能通过TCP读写网络中的数据。
ServerSocketChannel:可以监听新进来的TCP连接,像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。
Buffers:Buffer用于和NIO通道进行交互。数据是从通道读入缓冲区,从缓冲区写入到通道中的。
ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer
MappedByteBuffer
Selectors:选择器,是Java NIO中能够检测一到多个NIO通道,并能够知晓通道是否为诸如读写事件做好准备的组件。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接。
两者区别:
IO NIO
面向流 面向缓冲
阻塞IO 非阻塞IO
无 选择器
IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方。此外,它不能前后移动流中的数据。当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。
NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。当线程从通道读取数据到缓冲区时,线程还是可以进行其他事情。当数据被写入到缓冲区时,线程可以继续处理它。从缓冲区写入通道也类似
MySQL数据库
数据类型
数值类型(12)
1、整数类型(6)
2、定点数(2)
DECIMAL和NUMERIC类型在MySQL中视为相同的类型。它们用于保存必须为确切精度的值。
- salary DECIMAL(5,2)
我们看到其中有两个参数,即DECIMAL(M,D),其中M表示十进制数字总的个数,D表示小数点后面数字的位数,上例中的取值范围为-999.99~999.99。
如果存储时,整数部分超出了范围(如上面的例子中,添加数值为1000.01),MySql就会报错,不允许存这样的值。
如果存储时,小数点部分若超出范围,就分以下情况:
若四舍五入后,整数部分没有超出范围,则只警告,但能成功操作并四舍五入删除多余的小数位后保存。如999.994实际被保存为999.99。
若四舍五入后,整数部分超出范围,则MySql报错,并拒绝处理。如999.995和-999.995都会报错。
M的默认取值为10,D默认取值为0。如果创建表时,某字段定义为decimal类型不带任何参数,等同于decimal(10,0)。带一个参数时,D取默认值。
M的取值范围为1~65,取0时会被设为默认值,超出范围会报错。
D的取值范围为0~30,而且必须<=M,超出范围会报错。
所以,很显然,当M=65,D=0时,可以取得最大和最小值。
3、浮点数(3)
MySql中的浮点类型有float,double和real。他们定义方式为:FLOAT(M,D) 、 REAL(M,D) 、 DOUBLE PRECISION(M,D)。
REAL就是DOUBLE ,如果SQL服务器模式包括REAL_AS_FLOAT选项,REAL是FLOAT的同义词而不是DOUBLE的同义词。
“(M,D)”表示该值一共显示M位整数,其中D位位于小数点后面。例如,定义为FLOAT(7,4)的一个列可以显示为-999.9999。MySQL保存值时进行四舍五入,因此如果在FLOAT(7,4)列内插入999.00009,近似结果是999.0001。
FLOAT和DOUBLE中的M和D的取值默认都为0,即除了最大最小值,不限制位数。允许的值理论上是-1.7976931348623157E+308-2.2250738585072014E-308、0和2.2250738585072014E-3081.7976931348623157E+308。M、D范围如下(MySql5.7实测,与IEEE标准计算的实际是不同的,下面介绍):
M取值范围为0~255。FLOAT只保证6位有效数字的准确性,所以FLOAT(M,D)中,M<=6时,数字通常是准确的。如果M和D都有明确定义,其超出范围后的处理同decimal。
D取值范围为0~30,同时必须<=M。double只保证16位有效数字的准确性,所以DOUBLE(M,D)中,M<=16时,数字通常是准确的。如果M和D都有明确定义,其超出范围后的处理同decimal。
FLOAT和DOUBLE中,若M的定义分别超出7和17,则多出的有效数字部分,取值是不定的,通常数值上会发生错误。因为浮点数是不准确的,所以我们要避免使用“=”来判断两个数是否相等。
MySql中的浮点数遵循IEEE 754标准。
内存中,FLOAT占4-byte(1位符号位 8位表示指数 23位表示尾数),DOUBLE占8-byte(1位符号位 11位表示指数 52位表示尾数)。IEEE754标准还对尾数的格式做了规范:d.dddddd…,小数点左面只有1位且不能为零,计算机内部是二进制,因此,尾数小数点左面部分总是1。显然,这个1可以省去,以提高尾数的精度。由上可知,单精度浮点数的尾数是用24bit表示的,双精度浮点数的尾数是用53bit表示的。所以就能算出取值范围和准确的有效位数了,但MySql中其实略有不同。
4、BIT(1)
BIT数据类型可用来保存位字段值。BIT(M)类型允许存储M位值。M范围为1~64,默认为1。
BIT其实就是存入二进制的值,类似010110。
如果存入一个BIT类型的值,位数少于M值,则左补0.
如果存入一个BIT类型的值,位数多于M值,MySQL的操作取决于此时有效的SQL模式:
如果模式未设置,MySQL将值裁剪到范围的相应端点,并保存裁减好的值。
如果模式设置为traditional(“严格模式”),超出范围的值将被拒绝并提示错误,并且根据SQL标准插入会失败。
下面是官方示例:
- mysql> CREATE TABLE t (b BIT(8));
- mysql> INSERT INTO t SET b = b’11111111’;
- mysql> INSERT INTO t SET b = b’1010’;
- mysql> INSERT INTO t SET b = b’0101’;
- mysql> SELECT b+0, BIN(b+0), OCT(b+0), HEX(b+0) FROM t;
- ±-----±---------±---------±---------+
- | b+0 | BIN(b+0) | OCT(b+0) | HEX(b+0) |
- ±-----±---------±---------±---------+
- | 255 | 11111111 | 377 | FF |
- | 10 | 1010 | 12 | A |
- | 5 | 101 | 5 | 5 |
- ±-----±---------±---------±---------+
字符串类型(14)
字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。
1、CHAR和VARCHAR类型(2)
CHAR和VARCHAR类型声明的长度表示你想要保存的最大字符数。例如,CHAR(30)可以占用30个字符。默认长度都为255。
CHAR列的长度固定为创建表时声明的长度。长度可以为从0到255的任何值。当保存CHAR值时,在它们的右边填充空格以达到指定的长度。当检索到CHAR值时,尾部的空格被删除掉,所以,我们在存储时字符串右边不能有空格,即使有,查询出来后也会被删除。在存储或检索过程中不进行大小写转换。
所以当char类型的字段为唯一值时,添加的值是否已经存在以不包含末尾空格(可能有多个空格)的值确定,比较时会在末尾补满空格后与现已存在的值比较。
VARCHAR列中的值为可变长字符串。长度可以指定为0到65,535之间的值(实际可指定的最大长度与编码和其他字段有关,比如,本人MySql使用utf-8编码格式,大小为标准格式大小的2倍,仅有一个varchar字段时实测最大值仅21844,如果添加一个char(3),则最大取值减少3。整体最大长度是65,532字节)。
同CHAR对比,VARCHAR值保存时只保存需要的字符数,另加一个字节来记录长度(如果列声明的长度超过255,则使用两个字节)。
VARCHAR值保存时不进行填充。当值保存和检索时尾部的空格仍保留,符合标准SQL。
如果分配给CHAR或VARCHAR列的值超过列的最大长度,则对值进行裁剪以使其适合。如果被裁掉的字符不是空格,则会产生一条警告。如果裁剪非空格字符,则会造成错误(而不是警告)并通过使用严格SQL模式禁用值的插入。
下面显示了将各种字符串值保存到CHAR(4)和VARCHAR(4)列后的结果:
表中最后一行的值只适用在不使用严格模式时;如果MySQL运行使用严格模式,超过列长度的值不保存,并且会出现错误。
因为空格的原因,相同的值存入到长度都足够的varvhar和char中,取出可能会不同,比如"a"和"a "。
2、BINARY和VARBINARY类型(2)
BINARY和VARBINARY类型类似于CHAR和VARCHAR类型,但是不同的是,它们存储的不是字符字符串,而是二进制串。所以它们没有字符集,并且排序和比较基于列值字节的数值值。
当保存BINARY值时,在它们右边填充0x00(零字节)值以达到指定长度。取值时不删除尾部的字节。比较时所有字节很重要(因为空格和0x00是不同的,0x00<空格),包括ORDER BY和DISTINCT操作。比如插入’a ‘会变成’a \0’。
对于VARBINARY,插入时不填充字符,选择时不裁剪字节。比较时所有字节很重要。
当类型为BINARY的字段为主键时,应考虑上面介绍的存储方式。
3、BLOB和TEXT类型(8)
BLOB是一个二进制大对象,可以容纳可变数量的数据。有4种BLOB类型:TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB。它们只是可容纳值的最大长度不同。
有4种TEXT类型:TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT。这些对应4种BLOB类型,有相同的最大长度和存储需求。
BLOB列被视为二进制字符串。TEXT列被视为字符字符串,类似CHAR和BINARY。
在TEXT或BLOB列的存储或检索过程中,不存在大小写转换。
未运行在严格模式时,如果你为BLOB或TEXT列分配一个超过该列类型的最大长度的值,值被截取以保证适合。如果截掉的字符不是空格,将会产生一条警告。使用严格SQL模式,会产生错误,并且值将被拒绝而不是截取并给出警告。
在大多数方面,可以将BLOB列视为能够足够大的VARBINARY列。同样,可以将TEXT列视为VARCHAR列。
BLOB和TEXT在以下几个方面不同于VARBINARY和VARCHAR:
当保存或检索BLOB和TEXT列的值时不删除尾部空格。(这与VARBINARY和VARCHAR列相同)。
比较时将用空格对TEXT进行扩充以适合比较的对象,正如CHAR和VARCHAR。
对于BLOB和TEXT列的索引,必须指定索引前缀的长度。对于CHAR和VARCHAR,前缀长度是可选的。
BLOB和TEXT列不能有默认值。
MySQL Connector/ODBC将BLOB值定义为LONGVARBINARY,将TEXT值定义为LONGVARCHAR。
BLOB或TEXT对象的最大大小由其类型确定,但在客户端和服务器之间实际可以传递的最大值由可用内存数量和通信缓存区大小确定。你可以通过更改max_allowed_packet变量的值更改消息缓存区的大小,但必须同时修改服务器和客户端程序。
每个BLOB或TEXT值分别由内部分配的对象表示。
它们(TEXT和BLOB同)的长度:
Tiny:最大长度255个字符(2^8-1)
BLOB或TEXT:最大长度65535个字符(2^16-1)
Medium:最大长度16777215个字符(2^24-1)
LongText 最大长度4294967295个字符(2^32-1)
实际长度与编码有关,比如utf-8的会减半。
4、ENUM(1)
MySql中的ENUM是一个字符串对象,其值来自表创建时在列规定中显式枚举的一列值。
可以插入空字符串""和NULL:
如果你将一个非法值插入ENUM(也就是说,允许的值列之外的字符串),将插入空字符串以作为特殊错误值。该字符串与“普通”空字符串不同,该字符串有数值值0。
如果将ENUM列声明为允许NULL,NULL值则为该列的一个有效值,并且默认值为NULL。如果ENUM列被声明为NOT NULL,其默认值为允许的值列的第1个元素。
值的索引规则如下:
来自列规定的允许的值列中的值从1开始编号。
空字符串错误值的索引值是0。所以,可以使用下面的SELECT语句来找出分配了非法ENUM值的行:mysql> SELECT * FROM tbl_name WHERE enum_col=0;
NULL值的索引是NULL。
如下例:
ENUM最多可以有65,535个元素。当创建表时,ENUM成员值的尾部空格将自动被删除。
使用方式:
- CREATE TABLE shirts (
- name VARCHAR(40),
- size ENUM(‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’)
- );
- INSERT INTO shirts (name, size) VALUES (‘dress shirt’,‘large’),(‘t-shirt’,‘medium’),(‘polo shirt’,‘small’);
- SELECT name, size FROM shirts WHERE size = ‘medium’;
- UPDATE shirts SET size = ‘small’ WHERE size = ‘large’;
如果将返回值设为数值,将返回索引值,比如讲上面的查询语句改为: - SELECT name, size+0 FROM shirts WHERE size = ‘medium’;
如果将一个数字保存到ENUM列,数字被视为索引,并且保存的值是该索引对应的枚举成员(这不适合LOAD DATA,它将所有输入视为字符串)。不建议使用类似数字的枚举值来定义一个ENUM列,因为这很容易引起混淆。
ENUM值根据索引编号进行排序)。例如,对于ENUM(‘a’,‘b’),'a’排在’b’前面,但对于ENUM(‘b’,‘a’),'b’排在’a’前面。空字符串排在非空字符串前面,并且NULL值排在所有其它枚举值前面。要想防止意想不到的结果,按字母顺序规定ENUM列。还可以使用GROUP BY CAST(col AS CHAR)或GROUP BY CONCAT(col)来确保按照词汇对列进行排序而不是用索引数字。
4、SET类型(1)
SET是一个字符串对象,可以有零或多个值,其值来自表创建时规定的允许的一列值。指定包括多个SET成员的SET列值时各成员之间用逗号(‘,’)间隔开。例如,指定为SET(‘one’, ‘two’) NOT NULL的列可以有下面的任何值:
‘’
‘one’
‘two’
‘one,two’
SET最多可以设置64个值。创建表时,SET成员值的尾部空格将自动被删除。检索时,保存在SET列的值使用列定义中所使用的大小写来显示。
MySQL用数字保存SET值,所保存值的低阶位对应第1个SET成员。如果在数值上下文中检索一个SET值,检索的值的位设置对应组成列值的SET成员。
例如,可以这样从一个SET列检索数值值:
-
mysql> SELECT set_col+0 FROM tbl_name;
如果将一个数字保存到SET列中,数字的二进制的1的位置确定了列值中的SET成员。对于指定为SET(‘a’,‘b’,‘c’,‘d’)的列,成员有下面的十进制和二进制值:如果你为该列分配一个值9,其二进制形式为1001,因此第1个和第4个SET值成员’a’和’d’被选择,结果值为 ‘a,d’。
对于包含多个SET元素的值,当插入值时元素所列的顺序并不重要。在值中一个给定的元素列了多少次也不重要。当以后检索该值时,值中的每个元素出现一次,根据表创建时指定的顺序列出元素。例如,假定某个列指定为SET(‘a’,‘b’,‘c’,‘d’): -
CREATE TABLE myset (col SET(‘a’, ‘b’, ‘c’, ‘d’));
-
INSERT INTO myset (col) VALUES (‘a,d’), (‘d,a’), (‘a,d,a’), (‘a,d,d’), (‘d,a,d’);
-
SELECT *,col+0 FROM myset;
-
SELECT *,col+0 FROM myset where col=‘a,b’;
结果: -
a,d 9
-
a,d 9
-
a,d 9
-
a,d 9
-
a,d 9
SET值按数字顺序排序。NULL值排在非NULL SET值的前面。
通常情况,可以使用FIND_IN_SET()函数或LIKE操作符搜索SET值:
mysql> SELECT * FROM tbl_name WHERE FIND_IN_SET(‘value’,set_col)>0;
mysql> SELECT * FROM tbl_name WHERE set_col LIKE ‘%value%’;
第1个语句找出SET_col包含value set成员的行。第2个类似,但有所不同:它在其它地方找出set_col包含value的行,甚至是在另一个SET成员的子字符串中。
下面的语句也是合法的:
mysql> SELECT * FROM tbl_name WHERE set_col & 1;
mysql> SELECT * FROM tbl_name WHERE set_col = ‘val1,val2’;
第1个语句寻找包含第1个set成员的值。第2个语句寻找一个确切匹配的值。应注意第2类的比较。将set值与’val1,val2’比较返回的结果与同’val2,val1’比较返回的结果不同。指定值时的顺序应与在列定义中所列的顺序相同。
如果想要为SET列确定所有可能的值,使用SHOW COLUMNS FROM tbl_name LIKE set_col并解析输出中第2列的SET定义。
有什么实际应用呢?
比如我们设定用户的权限控制,一个用户可能会有多种权限,我们使用所有权限创建一个SET类型的字段,我们不需要用一系列int来定义各种权限了,直接使用一个SET字段即可: -
/*
-
用户权限permission表
-
*/
-
create table user_permission(
-
id int UNSIGNED not null auto_increment,
-
user_id int not null ,
-
permission set(‘阅读’,‘评论’,‘发帖’) not null,
-
primary key(id),
-
unique (user_id)
-
);
-
desc user_permission;
-
insert into user_permission values (0,1,‘阅读’),(0,2,‘阅读’),(0,3,‘阅读,评论’);
-
insert into user_permission values (0,4,‘阅读,评论,发帖’);
-
select *,permission+0 from user_permission;
-
select permission from user_permission where user_id=1;
-
select * from user_permission where permission & 10;
-
SELECT * FROM user_permission WHERE FIND_IN_SET(‘评论’,permission)>0;
时间日期类型(5)
他们的“0”值如下:
1、DATE, DATETIME, 和TIMESTAMP类型(3)
这三者其实是关联的,都用来表示日期或时间。
当你需要同时包含日期和时间信息的值时则使用DATETIME类型。MySQL以’YYYY-MM-DD HH:MM:SS’格式检索和显示DATETIME值。支持的范围为’1000-01-01 00:00:00’到’9999-12-31 23:59:59’。
当你只需要日期值而不需要时间部分时应使用DATE类型。MySQL用’YYYY-MM-DD’格式检索和显示DATE值。支持的范围是’1000-01-01’到 ‘9999-12-31’。
TIMESTAMP类型同样包含日期和时间,范围从’1970-01-01 00:00:01’ UTC 到’2038-01-19 03:14:07’ UTC。
可以使用任何常见格式指定DATETIME、DATE和TIMESTAMP值:
‘YYYY-MM-DD HH:MM:SS’或’YY-MM-DD HH:MM:SS’格式的字符串。允许“不严格”语法:任何标点符都可以用做日期部分或时间部分之间的间割符。例如,‘98-12-31 11:30:45’、‘98.12.31 11+30+45’、‘98/12/31 113045’和’98@12@31 113045’是等价的。
‘YYYY-MM-DD’或’YY-MM-DD’格式的字符串。这里也允许使用“不严格的”语法。例如,‘98-12-31’、‘98.12.31’、‘98/12/31’和’98@12@31’是等价的。
YYYYMMDDHHMMSS’或’YYMMDDHHMMSS’格式的没有间割符的字符串,假定字符串对于日期类型是有意义的。例如,‘19970523091528’和’970523091528’被解释为’1997-05-23 09:15:28’,但’971122129015’是不合法的(它有一个没有意义的分钟部分),将变为’0000-00-00 00:00:00’。
‘YYYYMMDD’或’YYMMDD’格式的没有间割符的字符串,假定字符串对于日期类型是有意义的。例如,‘19970523’和’970523’被解释为 ‘1997-05-23’,但’971332’是不合法的(它有一个没有意义的月和日部分),将变为’0000-00-00’。
YYYYMMDDHHMMSS或YYMMDDHHMMSS格式的数字,假定数字对于日期类型是有意义的。例如,19830905132800和830905132800被解释为 ‘1983-09-05 13:28:00’。
YYYYMMDD或YYMMDD格式的数字,假定数字对于日期类型是有意义的。例如,19830905和830905被解释为’1983-09-05’。
函数返回的结果,其值适合DATETIME、DATE或者TIMESTAMP上下文,例如NOW()或CURRENT_DATE。
对于包括日期部分间割符的字符串值,如果日和月的值小于10,不需要指定两位数。‘1979-6-9’与’1979-06-09’是相同的。同样,对于包括时间部分间割符的字符串值,如果时、分和秒的值小于10,不需要指定两位数。‘1979-10-30 1:2:3’与’1979-10-30 01:02:03’相同。
数字值应为6、8、12或者14位长。如果一个数值是8或14位长,则假定为YYYYMMDD或YYYYMMDDHHMMSS格式,前4位数表示年。如果数字 是6或12位长,则假定为YYMMDD或YYMMDDHHMMSS格式,前2位数表示年。其它数字被解释为仿佛用零填充到了最近的长度。
指定为非限定符字符串的值使用给定的长度进行解释。如果字符串为8或14字符长,前4位数表示年。否则,前2位数表示年。从左向右解释字符串内出现的各部分,以发现年、月、日、小时、分和秒值。这说明不应使用少于6字符的字符串。例如,如果你指定’9903’,认为它表示1999年3月,MySQL将在你的表内插入一个“零”日期值。这是因为年和月值是99和03,但日部分完全丢失,因此该值不是一个合法的日期。但是,可以明显指定一个零值来代表缺少的月或日部分。例如,可以使用’990300’来插入值’1999-03-00’。
可以将一个日期类型的值分配给一个不同的日期类型。但是,值可能会更改或丢失一些信息:
如果你为一个DATETIME或TIMESTAMP对象分配一个DATE值,结果值的时间部分被设置为’00:00:00’,因为DATE值未包含时间信息。
如果你为一个DATE对象分配一个DATETIME或TIMESTAMP值,结果值的时间部分被删除,因为DATE值未包含时间信息。
记住尽管可以使用相同的格式指定DATETIME、DATE和TIMESTAMP值,不同类型的值的范围却不同。例如,TIMESTAMP值不能早于1970或晚于2037。这说明一个日期,例如’1968-01-01’,虽然对于DATETIME或DATE值是有效的,但对于TIMESTAMP值却无效,如果分配给这样一个对象将被转换为0。
当指定日期值时请注意某些缺陷:
指定为字符串的值允许的非严格格式可能会欺骗。例如,值’10:11:12’由于‘:’间割符看上去可能象时间值,但如果用于日期上下文值则被解释为年’2010-11-12’。值’10:45:15’被转换为’0000-00-00’因为’45’不是合法月。
在非严格模式,MySQL服务器只对日期的合法性进行基本检查:年、月和日的范围分别是1000到9999、00到12和00到31。任何包含超出这些范围的部分的日期被转换成’0000-00-00’。请注意仍然允许你保存非法日期,例如’2002-04-31’。要想确保不使用严格模式时日期有效,应检查应用程序。 在严格模式,非法日期不被接受,并且不转换。
包含两位年值的日期会令人模糊,因为世纪不知道。MySQL使用以下规则解释两位年值: o 00-69范围的年值转换为2000-2069。 o 70-99范围的年值转换为1970-1999。
2、TIME类型(1)
MySQL以’HH:MM:SS’格式检索和显示TIME值(或对于大的小时值采用’HHH:MM:SS’格式)。
TIME值的范围可以从’-838:59:59’到’838:59:59’。小时部分会因此大的原因是TIME类型不仅可以用于表示一天的时间(必须小于24小时),还可能为某个事件过去的时间或两个事件之间的时间间隔(可以大于24小时,或者甚至为负)。
你可以用各种格式指定TIME值:
‘D HH:MM:SS.fraction’格式的字符串。还可以使用下面任何一种“非严格”语法:‘HH:MM:SS.fraction’、‘HH:MM:SS’、‘HH:MM’、‘D HH:MM:SS’、‘D HH:MM’、‘D HH’或’SS’。这里D表示日,可以取0到34之间的值。请注意MySQL还不保存分数。
‘HHMMSS’格式的没有间割符的字符串,假定是有意义的时间。例如,‘101112’被理解为’10:11:12’,但’109712’是不合法的(它有一个没有意义的分钟部分),将变为’00:00:00’。
HHMMSS格式的数值,假定是有意义的时间。例如,101112被理解为’10:11:12’。下面格式也可以理解:SS、MMSS、HHMMSS、HHMMSS.fraction。请注意MySQL还不保存分数。
函数返回的结果,其值适合TIME上下文,例如CURRENT_TIME。
对于指定为包括时间部分间割符的字符串的TIME值,如果时、分或者秒值小于10,则不需要指定两位数。‘8:3:2’与’08:03:02’相同。
为TIME列分配简写值时应注意。没有冒号,MySQL解释值时假定最右边的两位表示秒。(MySQL解释TIME值为过去的时间而不是当天的时间)。例如,你可能认为’1112’和1112表示’11:12:00’(11点过12分),但MySQL将它们解释为’00:11:12’(11分,12 秒)。同样,‘12’和12 被解释为 ‘00:00:12’。相反,TIME值中使用冒号则肯定被看作当天的时间。也就是说,‘11:12’表示’11:12:00’,而不是’00:11:12’。
超出TIME范围但合法的值被裁为范围最接近的端点。例如,‘-850:00:00’和’850:00:00’被转换为’-838:59:59’和’838:59:59’。
无效TIME值被转换为’00:00:00’。请注意由于’00:00:00’本身是一个合法TIME值,只从表内保存的一个’00:00:00’值还不能说出原来的值是 '00:00:00’还是不合法的值。
3、YEAR类型(1)
YEAR类型是一个单字节类型用于表示年。
MySQL以YYYY格式检索和显示YEAR值。范围是1901到2155。
可以指定各种格式的YEAR值:
四位字符串,范围为’1901’到’2155’。
四位数字,范围为1901到2155。
两位字符串,范围为’00’到’99’。'00’到’69’和’70’到’99’范围的值被转换为2000到2069和1970到1999范围的YEAR值。
两位整数,范围为1到99。1到69和70到99范围的值被转换为2001到2069和1970到1999范围的YEAR值。请注意两位整数范围与两位字符串范围稍有不同,因为你不能直接将零指定为数字并将它解释为2000。你必须将它指定为一个字符串’0’或’00’或它被解释为0000。
函数返回的结果,其值适合YEAR上下文,例如NOW()。
非法YEAR值被转换为0000。
各种类型占用的存储
1、数值类型
定点数的比较特殊,而且与具体版本也有关系,此处单独解释:
使用二进制格式将9个十进制(基于10)数压缩为4个字节来表示DECIMAL列值。每个值的整数和分数部分的存储分别确定。每个9位数的倍数需要4个字节,并且“剩余的”位需要4个字节的一部分。下表给出了超出位数的存储需求:
2、时间日期
从版本5.6.4开始,存储需求就有所改变,根据精度而定。不确定部分需要的存储如下:
比如,TIME(0), TIME(2), TIME(4), 和TIME(6) 分别使用3, 4, 5, 6 bytes。
3、字符串
类型的选择
为了优化存储,在任何情况下均应使用最精确的类型。
例如,如果列的值的范围为从1到99999,若使用整数,则MEDIUMINT UNSIGNED是好的类型。在所有可以表示该列值的类型中,该类型使用的存储最少。
用精度为65位十进制数(基于10)对DECIMAL 列进行所有基本计算(+、-、*、/)。
使用双精度操作对DECIMAL值进行计算。如果准确度不是太重要或如果速度为最高优先级,DOUBLE类型即足够了。为了达到高精度,可以转换到保存在BIGINT中的定点类型。这样可以用64位整数进行所有计算,根据需要将结果转换回浮点值。
存储引擎
1.修改存储引擎的方法:
1).通过修改MySQL配置文件实现:default-storage-engine=…engine
2).建表的时候指定 CREATE TABLE tbl_name() ENGINE=…engine
3).修改 ALTER TABLE tbl_name ENGINE=…engine
索引
常见索引的类型
Mysql常见索引有:主键索引、唯一索引、普通索引、全文索引、组合索引
PRIMARY KEY(主键索引) ALTER TABLE table_name
ADD PRIMARY KEY ( column
) UNIQUE(唯一索引) ALTER TABLE table_name
ADD UNIQUE (column
)
INDEX(普通索引) ALTER TABLE table_name
ADD INDEX index_name ( column
) FULLTEXT(全文索引) ALTER TABLE table_name
ADD FULLTEXT ( column
)
组合索引 ALTER TABLE table_name
ADD INDEX index_name ( column1
, column2
, column3
)
Mysql各种索引区别
普通索引(INDEX):最基本的索引,没有任何限制
唯一索引(UNIQUE):与"普通索引"类似,不同的就是:索引列的值必须唯一,但允许有空值。
主键索引(PRIMARY):它 是一种特殊的唯一索引,不允许有空值。
全文索引(FULLTEXT ):仅可用于 MyISAM 表, 用于在一篇文章中,检索文本信息的, 针对较大的数据,生成全文索引很耗时好空间。
组合索引:为了更多的提高mysql效率可建立组合索引,遵循”最左前缀“原则。
举个例子来说,比如你在为某商场做一个会员卡的系统。
这个系统有一个会员表
有下列字段:
会员编号 INT
会员姓名 VARCHAR(10)
会员身份证号码 VARCHAR(18)
会员电话 VARCHAR(10)
会员住址 VARCHAR(50)
会员备注信息 TEXT
那么这个 会员编号,作为主键,使用 PRIMARY
会员姓名 如果要建索引的话,那么就是普通的 INDEX
会员身份证号码 如果要建索引的话,那么可以选择 UNIQUE (唯一的,不允许重复)
会员备注信息 , 如果需要建索引的话,可以选择 FULLTEXT,全文搜索。
不过 FULLTEXT 用于搜索很长一篇文章的时候,效果最好。
用在比较短的文本,如果就一两行字的,普通的 INDEX 也可以。
创建索引:CREATE UNIQUE INDEX indexName ON tableName(tableColumns(length))
删除索引的语法:DROP INDEX index_name ON tableName
索引分单列索引和组合索引
单列索引:即一个索引只包含单个列,一个表可以有多个单列索引,但这不是组合索引。
组合索引:即一个索包含多个列。
为了形象地对比两者,再建一个表:
1
2
3
4
5
6
7
8
9
10
11
12
13 CREATE TABLE myIndex (
i_testID INT NOT NULL AUTO_INCREMENT,
vc_Name VARCHAR(50) NOT NULL,
vc_City VARCHAR(50) NOT NULL,
i_Age INT NOT NULL,
i_SchoolID INT NOT NULL, PRIMARY KEY (i_testID)
);
在这10000条记录里面七上八下地分布了5条vc_Name="erquan"的记录,只不过city,age,school的组合各不相同。
来看这条T-SQL:
复制代码代码如下:
SELECT i_testID FROM myIndex WHERE vc_Name=‘erquan’ AND vc_City=‘郑州’ AND i_Age=25;
首先考虑建单列索引:
在vc_Name列上建立了索引。执行T-SQL时,MYSQL很快将目标锁定在了vc_Name=erquan的5条记录上,取出来放到一中间结果集。在这个结果集里,先排除掉vc_City不等于"郑州"的记录,再排除i_Age不等于25的记录,最后筛选出唯一的符合条件的记录。
虽然在vc_Name上建立了索引,查询时MYSQL不用扫描整张表,效率有所提高,但离我们的要求还有一定的距离。同样的,在vc_City和i_Age分别建立的单列索引的效率相似。
为了进一步榨取MySQL的效率,就要考虑建立组合索引。就是将vc_Name,vc_City,i_Age建到一个索引里:
ALTER TABLE myIndex ADD INDEX name_city_age (vc_Name(10),vc_City,i_Age);–注意了,建表时,vc_Name长度为50,这里为什么用10呢?因为一般情况下名字的长度不会超过10,这样会加速索引查询速度,还会减少索引文件的大小,提高INSERT的更新速度。
执行T-SQL时,MySQL无须扫描任何记录就到找到唯一的记录!!
肯定有人要问了,如果分别在vc_Name,vc_City,i_Age上建立单列索引,让该表有3个单列索引,查询时和上述的组合索引效率一样吧?嘿嘿,大不一样,远远低于我们的组合索引~~虽然此时有了三个索引,但MySQL只能用到其中的那个它认为似乎是最有效率的单列索引。
建立这样的组合索引,其实是相当于分别建立了
1
2
3 vc_Name,vc_City,i_Age
vc_Name,vc_City
vc_Name
这样的三个组合索引!为什么没有vc_City,i_Age等这样的组合索引呢?这是因为mysql组合索引"最左前缀"的结果。简单的理解就是只从最左面的开始组合。并不是只要包含这三列的查询都会用到该组合索引,下面的几个T-SQL会用到:
1
2 SELECT * FROM myIndex WHREE vc_Name=“erquan” AND vc_City=“郑州”
SELECT * FROM myIndex WHREE vc_Name=“erquan”
而下面几个则不会用到:
1
2 SELECT * FROM myIndex WHREE i_Age=20 AND vc_City=“郑州”
SELECT * FROM myIndex WHREE vc_City=“郑州”
使用索引
到此你应该会建立、使用索引了吧?但什么情况下需要建立索引呢?一般来说,在WHERE和JOIN中出现的列需要建立索引,但也不完全如此,因为MySQL只对 <,<=,=,>,>=,BETWEEN,IN,以及某些时候的LIKE(后面有说明)才会使用索引。
SELECT t.vc_Name FROM testIndex t LEFT JOIN myIndex m ON t.vc_Name=m.vc_Name WHERE m.i_Age=20 AND m.vc_City=‘郑州’ 时,有对myIndex表的vc_City和i_Age建立索引的需要,由于testIndex表的vc_Name开出现在了JOIN子句中,也有对它建立索引的必要。
刚才提到了,只有某些时候的LIKE才需建立索引?是的。因为在以通配符 % 和 _ 开头作查询时,MySQL不会使用索引,如
1 SELECT * FROM myIndex WHERE vc_Name like’erquan%’
会使用索引,而
1 SELECT * FROM myIndex WHEREt vc_Name like’%erquan’
就不会使用索引了。
索引的不足之处
上面说了那么多索引的好话,它真的有像传说中那么优秀么?当然会有缺点了。
1.虽然索引大大提高了查询速度,同时却会降低更新表的速度,如对表进行INSERT、UPDATE和DELETE。因为更新表时,MySQL不仅要保存数据,还要保存一下索引文件
2.建立索引会占用磁盘空间的索引文件。一般情况这个问题不太严重,但如果你在一个大表上创建了多种组合索引,索引文件的会膨胀很快。
索引失效场景
1.WHERE字句的查询条件里有不等于号(WHERE column!=…),MYSQL将无法使用索引
2.类似地,如果WHERE字句的查询条件里使用了函数(如:WHERE DAY(column)=…),MYSQL将无法使用索引
3.在JOIN操作中(需要从多个数据表提取数据时),MYSQL只有在主键和外键的数据类型相同时才能使用索引,否则即使建立了索引也不会使用
4.如果WHERE子句的查询条件里使用了比较操作符LIKE和REGEXP,MYSQL只有在搜索模板的第一个字符不是通配符的情况下才能使用索引。比如说,如果查询条件是LIKE ‘abc%’,MYSQL将使用索引;如果条件是LIKE ‘%abc’,MYSQL将不使用索引。
5.在ORDER BY操作中,MYSQL只有在排序条件不是一个查询条件表达式的情况下才使用索引。尽管如此,在涉及多个数据表的查询里,即使有索引可用,那些索引在加快ORDER BY操作方面也没什么作用。
6.如果某个数据列里包含着许多重复的值,就算为它建立了索引也不会有很好的效果。比如说,如果某个数据列里包含了净是些诸如“0/1”或“Y/N”等值,就没有必要为它创建一个索引。
7.索引有用的情况下就太多了。基本只要建立了索引,除了上面提到的索引不会使用的情况下之外,其他情况只要是使用在WHERE条件里,ORDER BY 字段,联表字段,一般都是有效的。 建立索引要的就是有效果。 不然还用它干吗? 如果不能确定在某个字段上建立的索引是否有效果,只要实际进行测试下比较下执行时间就知道。
8.如果条件中有or(并且其中有or的条件是不带索引的),即使其中有条件带索引也不会使用(这也是为什么尽量少用or的原因)。注意:要想使用or,又想让索引生效,只能将or条件中的每个列都加上索引
9.如果列类型是字符串,那一定要在条件中将数据使用引号引用起来,否则不使用索引
10.如果mysql估计使用全表扫描要比使用索引快,则不使用索引
不使用NOT IN和<>操作
NOT IN和<>操作都不会使用索引将进行全表扫描。NOT IN可以NOT EXISTS代替,id<>3则可使用id>3 or id<3来代替。MySQL只有对以下操作符才使用索引:<,<=,=,>,>=,BETWEEN,IN,以及某些时候的LIKE。可以在LIKE操作中使用索引的情形是指另一个操作数不是以通配符(%或者_)开头的情形。