3月5号 百词斩

1.内部类和内部静态类的区别

a.普通内部类隐含的保存了指向外部类的对象的指针，而静态内部类没有
b.静态内部类可以有静态成员，而非静态内部类则不允许有静态成员
c.静态内部类只能访问外部类的静态成员，而非静态内部类可以访问外部类的所以成员
d.实例化一个普通内部类的方法：

OutObj objOut = new OutObj();
OutObj.InObj inObj = objOut.new InObj();

e.实例化一个静态内部类的方法：

OutObj.StaticInObj inner = new OutObj.StaticInObj(); 

2.两个activity之间如何传输比较大的数据(几十M)

首先，Activity可以用以下5中方式传递数据
a.Intent
Intent传递的数据不能超过1M，当数据太大的时候会抛出TransactionTooLargeException异常，或者无法通过该Intent启动Activity
The Binder transaction buffer has a limited fixed size, currently 1Mb
b.Application
我经常在Application中存储Context对象，这样在应用的任何地方都能获得Context对象了，那么我们也可以在Application中存储数据。
c.使用单例

public class DataHolder{
    private String data;
    public String getData(){return data;}
    public void setData(String data){this.data = data;}
    private static final DataHolder holder = new DataHolder();
    public static DataHolder getInstance(){
        return holder;
    }
}

在Activity A中设置数据：

DataHolder.getInstance().setData(data);

在Activity B中读取数据：

String data = DataHolder.getInstance().getData();

d.静态成员变量
实现和原理和单例差不多
e.持久化(sql,share preference,file)
优点：全局都能访问，数据不会丢失
缺点：操作麻烦，效率低下

总结：综上所述，除了Intent外，其他四种我们都可以尝试下(Application, 单例, 静态成员变量, 数据持久化)

3.Activity A启动Activity B，B如何向A传输数据

假设我们两个Activity的名字分别为”ActivityA”与”ActivityB”
在ActivityA中

''''''
Intent intent = new Intent("ActivityA.this", "ActivityB.class");
startActivityForResult(Intent intent, int requestCode);
''''''
onActivityResult(int requestCode, int resultCode, Intent data);
''''''

在ActivityB中

''''''
setResult(int resultCode, Intent data);
''''''

(1) A中使用startActivityForResult(Intent intent, int requestCode)来启动B，且指定了requestCode，这个参数的意义是A可能会启动很多个Activity，用这个参数来标识这些Activity
(2) B中用setResult(int resultCode, Intent data)来向A返回数据
(3) 经过(2)后，A中的onActivityResult(int requestCode, int resultCode, Intent data)就会回调

4.插入排序和归并排序的比较

插入排序：

Java:
void InsertSort(int data[]) {
    for (int i = 1; i < data.length; i++) {
        int j = i, tmp = data[i];
        while (j > 0 && data[j - 1] > tmp) {
            data[j] = data[j - 1];
            j--;
        }
        data[j] = tmp;
    }
}

归并排序：

void MergeArray(int data[], int start, int mid, int end, int temp[])
{
    int i = start, j = mid + 1;
    int m = mid, n = end;
    int k = 0;

    while(i <= m && j <= n)
    {
        if(data[i] <= data[j])
            temp[k++] = data[i++];
        else
            temp[k++] = data[j++];
    }

    while(i <= m)
        temp[k++] = data[i++];

    while(j <= n)
        temp[k++] = data[j++];

    for(int i = 0; i < k; i++)
    {
        data[start + i] = temp[i];
    }
}

void MergeSort(int data[], int start, int end, int temp[])
{
    if(start < end)
    {
        int mid = (start + end) / 2;
        MergeSort(data, start, mid, temp);
        MergeSort(data, mid + 1, end, temp);
        MergeArray(data, start, mid, end, temp);
    }
}

当数据规模比较小或者数据基本有序的情况下用插入排序比较好
若数据规模比较大，则采用归并排序(nlogn)

5.Activity和Fragment如何传输数据

1.Activity向Fragment传递数据
在Fragment中可以调用getActivity()获得实例，然后可以调用getViewById()等方法获得控件实例

View listView = getActivity().findViewById(R.id.list);

2.Fragment向Activity传递数据——Fragment实例
a.在Activity中定义Fragment时，保存Fragment的实例
b.调用FragmentManager，接着使用findFragmentById()或者findFragmentByTag()获得相应Fragment的实例

ExampleFragment fragment = (ExampleFragment) getFragmentManager().findFragmentById(R.id.example_fragment);

3.Fragment向Activity传递数据——Fragment接口
Activity中有一个按钮，Activity中有一个Fragment，Fragment中有一个EditText，当点击Activity中的按钮后，就会Toast出EditText的内容

解决方案：在Fragment中定义一个接口，并要求宿主Activity实现这个接口。

//fragment_my.xml
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="300dp"
    android:background="#ccc"
    tools:context="com.coder_ken.demo1.MyFragment">

    <EditText
        android:id="@+id/editText1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10">
        <requestFocus />
    </EditText>

</FrameLayout>

//MyFragment.java
public class MyFragment extends Fragment {
    private EditText editText;

    public MyFragment() {
        // Required empty public constructor
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_my, container, false);
        editText = (EditText) view.findViewById(R.id.editText1);
        return view;
    }

    public void getEditText(CallBack callBack){
        String result = editText.getText().toString();
        callBack.getResult(result);
    }

    public interface CallBack {
        public void getResult(String result);
    }

}

//activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <LinearLayout
        android:id="@+id/fragment"
        android:layout_width="match_parent"
        android:layout_height="200dp"
        android:orientation="horizontal"></LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:orientation="vertical" >

        <EditText
            android:id="@+id/editText1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10" >
            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="获得Fragment的值" />
    </LinearLayout>

</LinearLayout>

//MainActivity.java
public class MainActivity extends AppCompatActivity {

    private FragmentManager manager;
    private FragmentTransaction transaction;
    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        button = (Button) findViewById(R.id.button);
        manager = getSupportFragmentManager();
        transaction = manager.beginTransaction();
        final MyFragment myFragment = new MyFragment();
        transaction.add(R.id.fragment, myFragment, "");
        transaction.commit();
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                myFragment.getEditText(new MyFragment.CallBack() {
                    @Override
                    public void getResult(String result) {
                        Toast.makeText(MainActivity.this, result, Toast.LENGTH_LONG).show();
                    }
                });
            }
        });
    }
}

4.Fragment与Fragment之间通信
既然Activity->Fragment与Fragment->Activity之间的通信都解决了，那么：
在FragmentA中获取Activity的实例，通过Activity找到FragmentB的实例，FragmentA与FragmentB就可以通信了。

6.hash实现的原理

什么是哈希表
哈希表是一种以键-值（key - value）存储的数据结构，只要我们输入待查找的key，就可以马上知道它的value。
哈希函数
若关键字为k，则其值存放在f(k)的存储地址上，那么这个对应关系f就称为哈希函数。
哈希算法
1.直接定址法：
2.数字分析法：
3.平方取中法：
4.折叠法：
5.除留余数法：
6.随机数法：
获取正整数哈希值最常用的方法是使用除留余数法。对于任意正整数K，计算k除以M的余数，M一般取素数
避免哈希冲突
1.拉链法
通过哈希函数，我们可以将键转换成数组的索引（0-M-1），但是对于两个或者多个键具有相同索引值的情况，我们需要有一种方法来处理这种冲突。

一种比较直接的方法是将大小为M的数组的每个元素指向一个链表，链表的每一个节点都存储散列值为该索引的键值对。

如图，John Smith和Sandra Dee的哈希值都是152，所以他们存储在152指向的链表当中。
对采用拉链法的哈希实现的查找分为两步，首先是根据散列值找到对应的链表，然后沿着链表顺序找到相应的键。
2.线性探测法
线性探测法是开放寻址法解决哈希冲突的一种方法，基本原理为，使用大小为M的数组来保存N个键值对，其中M > N，我们需要使用数组中的空位解决碰撞冲突。

上图中，“Ted Baker”是有唯一的哈希值153的，但是153现在被“Sandra
Dee”占用了。原先“Sandra
Dee”进行哈希的时候发现152已经被占用了，所以往下找发现153没有被占用，所以存放在153上，后来“Ted Baker”哈希到153上，发现已经被占用了，所以往下找，发现154没有被占用，所以存放到154上面了。
参考链接：http://www.cnblogs.com/yangecnu/p/Introduce-Hashtable.html 谢谢原文作者