面试-Java基础知识

扎实基础！

笔试让我明白了自己的一些问题。

byte a = 100;
byte b = 10;
byte c = a + b;
// 报错 默认最低是Int类型
byte c = (byte)a + b;
int c = a + b;

package com.lzy.test;

public class Test1 {
	
	public static void main(String[] args) {
		int a = 0;
		int b = a++;
		System.out.println(a);//1
		int c = ++a;
		System.out.println(a);//2
		System.out.println(a++);//2
		System.out.println(++a);//4
		System.out.println(b);//0
		System.out.println(c);//2
	}
}
public static void main(String[] args) {
		int a = 5;
		// a的变化：6	   7     8     9    10
		// b的变化： 5    7     7     8     10
		int b = a++ + ++a + a++ + a++ + ++a;
		System.out.println(b); //37
	}

public class Test2 {
	
	public static void main(String[] args) {
		int a = 0;
		//&对每一个都判断；
		if (a==0 & a++==1) {
			System.out.println("&");//不输出
		}
		System.out.println(a);//1
		//&&只要前面是false就输出false，而不继续判断后面了
		if (a==0 && a++==1) {
			System.out.println("&&");//不输出
		}
		if (a==1 && a++==1) {
			System.out.println("&&");//输出
		}
	}
}

// 随机数
	public static void main(String[] args) {
		// 随机数产生的范围是[0, 1)
		double num = Math.random();
		// 这样子[0, 0.5) [0.5, 1)才能真正平衡
		if (num >= 0.5) {
			System.out.println("成都");
		} else {
			System.out.println("赵雷");
		}
		// 输出指定范围的数字
		// [26, 38]
		// 方法一： (int)(Math.random()*(max - min) + min);
		int a = 25;
		int b = 38;
		
		int  scal = (int)(Math.random()*(b - a + 1)) + a;
		System.out.println(scal);
		// 方法二：
		int scall = (int)(Math.random() * 100 % 12) + a;
		System.out.println(scall);
	}

---

基础知识点

一：== 与 equal的区别：

1. == 是一个运算符。
2. Equals则是string对象的方法，可以.（点）出来。
3. 因为对象变量的存储的是对象在内存中的路径，即内存地址。所以用“==”比较时，即使
   对象的值相等，但是他们的内存地址不同(引用数据类型)，所以==的结果为false。故“==”用于比较两
   个变量的值是否相等，而不是变量引用的对象是否相等。
4. equal用于比较两个对象是否相同。
5. “==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】
   equal用于比较两个对象的值是否相同【不是比地址】

【特别注意】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。”==”比”equal”运行速度快,因为”==”只是比较引用.

二：public、protected、private、default（friendly）的区别:

public：可以被其他类访问
private：只能被自己访问和修改
protected:类内部、子类、同一个包中的类之间可以访问
default：作用域是包，可以不写。被认为是friendly

final关键字：

修饰类：表示该类不能被继承，final类的所有成员方法都会被隐式的指定为final方法
修饰方法：变是该方法不能被子类修改，类的private方法会被隐式的指定为final方法
修饰变量：基本数据变量不可以被更改
引用类型变量不可以再更改指向另一个对象

Java线程安全与非线程安全：

多线程安全优点体现在多个线程操作同一个对象，非线程安全 != 不安全
线程安全是通过线程同步控制来实现的，也就是synchronized关键字。
ArrayList是非线程安全 Vector是线程安全；
HashMap是非线程安全 HashTable是线程安全；
StringBuilder是非线程安全 StringBuffer是线程安全；
http://blog.csdn.net/YiZhiCXY/article/details/51335385

String、StringBuffer、StringBuilder的区别：

String： 字符串常量
StringBuffer: 字符串变量（线程安全） 多线程下有优势
StringBuilder: 字符串变量（非线程安全） 单线程下有优势

Array、ArrayList、Vectory、LinkedList的区别：(推荐看源码)

ArrayList是为可变数组实现的，当更多的元素添加到ArrayList的时候，它的大小会动态增大。它的元素可以通过get/set方法直接访问，因为ArrayList本质上是一个数组。

/**
 * Resizable-array implementation of the {@code List} interface.  Implements
 * all optional list operations, and permits all elements, including
 * {@code null}.  In addition to implementing the {@code List} interface,
 * this class provides methods to manipulate the size of the array that is
 * used internally to store the list.  (This class is roughly equivalent to
 * {@code Vector}, except that it is unsynchronized.)
  * <p>The {@code size}, {@code isEmpty}, {@code get}, {@code set},
 * {@code iterator}, and {@code listIterator} operations run in constant
 * time.  The {@code add} operation runs in <i>amortized constant time</i>,
 * that is, adding n elements requires O(n) time.  All of the other operations
 * run in linear time (roughly speaking).  The constant factor is low compared
 * to that for the {@code LinkedList} implementation.
 */

LinkedList是为双向链表实现的,非线程安全(not )

/**
 * Doubly-linked list implementation of the {@code List} and {@code Deque}
 * interfaces.  Implements all optional list operations, and permits all
 * elements (including {@code null}).
 *
 * <p>All of the operations perform as could be expected for a doubly-linked
 * list.  Operations that index into the list will traverse the list from
 * the beginning or the end, whichever is closer to the specified index.
 *
 * <p><strong>Note that this implementation is not synchronized.</strong>
 * If multiple threads access a linked list concurrently, and at least
 * one of the threads modifies the list structurally, it <i>must</i> be
 * synchronized externally.  (A structural modification is any operation
 * that adds or deletes one or more elements; merely setting the value of
 * an element is not a structural modification.)  This is typically
 * accomplished by synchronizing on some object that naturally
 * encapsulates the list.
 */

Vector与ArrayList相似，但是它是同步的。

/**
 * The {@code Vector} class implements a growable array of
 * objects. Like an array, it contains components that can be
 * accessed using an integer index. However, the size of a
 * {@code Vector} can grow or shrink as needed to accommodate
 * adding and removing items after the {@code Vector} has been created.
 *
 * <p>Each vector tries to optimize storage management by maintaining a
 * {@code capacity} and a {@code capacityIncrement}. The
 * {@code capacity} is always at least as large as the vector
 * size; it is usually larger because as components are added to the
 * vector, the vector's storage increases in chunks the size of
 * {@code capacityIncrement}. An application can increase the
 * capacity of a vector before inserting a large number of
 * components; this reduces the amount of incremental reallocation.
 */

如果你的程序是线程安全的，ArrayList是一个比较好的选择。当更多的元素被添加的时候，Vector和ArrayList需要更多的空间。Vector每次扩容会增加一倍的空间，而ArrayList增加50%。

注意：ArrayList默认的初始空间大小相当的小，通过构造函数去初始化一个更大的空间是一个好习惯，可以避免扩容开销。
部分引自于：https://www.cnblogs.com/chenpi/p/5505375.html

Map、List、Set、Array的区别：

https://www.cnblogs.com/chuanheliu/p/6363948.html

Iterator 的hasNext方法和next方法:

hasNext():如果仍有元素可以迭代，则返回 true。（换句话说，如果 next 返回了元素而不是抛出异常，则返回 true）。
next():返回迭代的下一个元素。

/**
 * Returns {@code true} if the iteration has more elements.
 * (In other words, returns {@code true} if {@link [[next]]} would
 * return an element rather than throwing an exception.)
 *
 * @return {@code true} if the iteration has more elements
 */
boolean hasNext();

/**
 * Returns the next element in the iteration.
 *
 * @return the next element in the iteration
 * @throws NoSuchElementException if the iteration has no more elements
 */
E next();

JAVA多线程和并发基础面试问答:

http://www.cnblogs.com/dolphin0520/p/3932934.html

Oracle数据库中TRUNCATE 与 DELETE 的区别：

1. ROLLBACK可以撤销DELETE操作但撤销不了TRUNCATE操作
2. TRUNCATE TABLE比DELETE的速度快；
3. TRUNCATE TABLE是删除表的所有行，而DELETE是删除表的一行或者多行
4. TRUNCATE TABLE在遇到任何一行违反约束(外键约束)时仍然删除表的所有行，但表的结构及其列、约束、索引等保持不变，DELETE则直接返回报错。
5. 对于被外键约束的表，不能使用TRUNCATE TABLE，而应该使用不带WHERE语句的DELETE语句。
6. 如果想保留标识计数值，要用DELETE，因为TRUNCATE TABLE会对新行标志符列搜用的计数值重置为该列的种子。

序列化的作用：

为了保存在内存中的各种对象的状态（序列化），并且可以把保存的对象状态再读出来（反序列化）。

JAVA 中的 super和this

this的用法

1. 指向当前对象本身。
2. 形参与成员名字重名，用this来区分

   public class User {
       private String name;
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
   		// 形参与成员名字重名，用this来区分
           this.name = name;
       }
   }

   super用法

3. 指向当前对象的父类
4. 子类中的成员变量或方法与父类同名

   public class TestTest extends Country {
       String name;
       void value() {
           name = "Shanghai";
           super.value();
           System.out.println(super.name);
       }
       public static void main(String[] args) {
           TestTest tt = new TestTest();
           tt.value();
       }
   }
   
   class Country {
       String name;
       void value() {
           name = "China";
       }
   }