一般来说，一个Android工程的目录结构如下图所示。
1：src
JAVA源代码都放在这里面。
2：gen
编译器自动生成的一些JAVA代码
3：Android 4.2
Android平台(本工程用的版本是4.2)
4：Android dependencies
该目录出现在ADT16以后的版本中，是ADT第三方库新的引用方式，当我们需要引用第三方库的时候，只需要将
该库拷贝到libs文件夹中，ADT就会自动完成对该库的引用(如本例中android-support-v4.jar)
5：bin
该目录是编译之后的文件以及一些中间文件的存放目录，ADT先将工程编译成Android JAVA虚拟机(Dalvik Virtual Machine)
文件classes.dex. 最后将该classes.dex封装成apk包。(apk就是android平台生的安装程序包)。
6：libs
4中已经介绍，该目录用于存放第三方库,(新建工程时，默认会生成该目录，没有的话手动创建即可)。
7：res
存放项目中的资源文件，该目录中有资源添加时，R.java会自动记录下来。res目录下一般有如下几个子目录
drawable-hdpi, drawable-mdpi, drawable-xhdpi：存放图片文件（png, jpg), 三个子目录分别保存高，中，低质量的图片
layout：屏幕布局目录，layout目录内默认布局文件是activity_main.xml，可以在该文件内放置不同的布局结构和控件，来满足项目界面的需要，也可以新建布局文件。
menu：存放定义了应用程序菜单资源的XML文件。
values, values-v11, values-v14：存放定义了多种类型资源的XML文件。
package cn.thj.data_structures;
import java.util.Iterator;
public class MyArrayList<T> implements Iterable<T> {
// 定义默认的大小
private static final int DEFAULT_CAPACITY = 10;
private T[] Items;
private int size;
// 默认构造
public MyArrayList() {
clear();
};
// 清空集合
public void clear() {
size = 0;
ensureCapacity(DEFAULT_CAPACITY);
}
/**
* 保持集合容量增长
*
* @param newCapacity
*/
public void ensureCapacity(int newCapacity) {
if (newCapacity < size) {
return;
}
T[] old = Items;
Items = (T[]) new Object[newCapacity];
for (int i = 0; i < size(); i++) {
Items[i] = old[i];
}
}
// 返回集合的大小
public int size() {
return size;
}
// 是集合的容量为集合的大小
public void trimToSize() {
ensureCapacity(size());
}
// 判断集合是否为空
public boolean isEmpty() {
return size() == 0;
}
// 检查集合的边界，判断是否越界
private void RangeCheck(int index) {
if (index >size || index < 0)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
+ size);
}
// 取指定位置的值
public T get(int index) {
RangeCheck(index);
return Items[index];
}
// 给指定位置设值
public T set(int index, T newVal) {
RangeCheck(index);
T old = Items[index];
Items[index] = newVal;
return Items[index];
}
// 添加元素，默认添加到末尾
public boolean add(T val) {
add(size(), val);
return true;
}
/**
* 根据指定位置添加数据
*
* @param index
* 添加的位置
* @param val
* 添加的值
*/
public void add(int index, T val) {
RangeCheck(index);
if (Items.length == size()) {
ensureCapacity(size() * 2 + 1);
}
for (int i = size; i > index; i--) {
Items[i] = Items[i - 1];
}
Items[index] = val;
size++;
}
/**
* 删除指定位置的元素
*
* @param index
* 删除的位置
* @return removeItem
* 返回被删除的元素
*/
public T remove(int index) {
RangeCheck(index);
T removeItem = Items[index];
for (int i = index; i < size; i++) {
Items[i] = Items[i + 1];
}
size--;
return removeItem;
}
public Iterator<T> iterator() {
return new ArrayListIterator();
}
/**
*实现迭代器,这里是用一个内部类来实现的
*/
private class ArrayListIterator implements java.util.Iterator<T> {
private int current = 0;
private boolean okToRemove = false;
public boolean hasNext() {
return current < size();
}
public T next() {
if (!hasNext())
throw new java.util.NoSuchElementException();
okToRemove = true;
return Items[current++];
}
public void remove() {
if (!okToRemove)
throw new IllegalStateException();
MyArrayList.this.remove(--current);
okToRemove = false;
}
}
}
Hibernate工作原理及为什么要用？
原理：
1. 读取并解析配置文件
2. 读取并解析映射信息，创建SessionFactory
3. 打开Sesssion
4. 创建事务Transation
5. 持久化操作
6. 提交事务
7. 关闭Session
8. 关闭SesstionFactory
为什么要用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
2． Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
2. Hibernate3 提供了属性的延迟加载功能
当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
3． Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)