社区微信群开通啦，扫一扫抢先加入社区官方微信群
社区微信群
public int getNum() {
try {
int a = 1 / 0;
return 1;
} catch (Exception e) {
return 2;
} finally {
return 3;
}
}
代码在走到第 3 行的时候遇到了一个 MathException，这时第四行的代码就不会执行了，代码直接跳转到catch 语句中，走到第 6 行的时候，异常机制有这么一个原则“如果在 catch 中遇到了 return 或者异常等能使该函数终止的话，那么用 finally 就必须先执行完 finally 代码块里面的代码然后再返回值。”因此代码又跳到第 8行，可惜第 8 行是一个 return 语句，那么这个时候方法就结束了，因此第 6 行的返回结果就无法被真正返回。如果 finally 仅仅是处理了一个释放资源的操作，那么该道题最终返回的结果就是 2。因此上面返回值是 3。
Java 的基本数据类型都有哪些各占几个字节？
Java 有 8 种基本数据类型
byte 1
char 2
sort 2
int 4
float 4
double 8
long 8
boolean 1（boolean 类型比较特别可能只占一个 bit，多个 boolean 可能共同占用一个字节）
String 是基本数据类型吗？可以被继承吗？
String是引用类型，底层是用char数组实现的，String是final类，java 中被final修饰的类不能被继承，所以String不能被继承。
在 java 中 wait 和 sleep 方法的不同？
最大的不同是wait会释放锁，sleep会一直持有锁。wait通常用于线程间交互，sleep用于暂停执行。
什么是线程池，如何使用？
线程池就是事先将多个线程对象放到一个容器里，当使用的时候就不用new而是直接去线程池中拿线程即可，节省了开辟子线程的时间，提高了代码的执行效率。
在 JDK 的 java.util.concurrent.Executors 中提供了生成多种线程池的静态方法。
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
ScheduledExecutorService newScheduledThreadPool =
Executors.newScheduledThreadPool(4);
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
然后调用他们的 execute 方法即可。
final List<String> list = new ArrayList<String>();
List<String> proxyInstance = (List<String>)
Proxy.newProxyInstance(list.getClass().getClassLoader(),
list.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
return method.invoke(list, args);
}
});
proxyInstance.add("你好");
System.out.println(list);
<service android:name="com.baidu.location.f"
android:enabled="true"
android:process=":remote" ></service>
public class MyParcelable implements Parcelable {
private int mData;
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
public static final Parcelable.Creator<MyParcelable> CREATOR= new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
FragmentManager fragmentManager = getFragmentManager();
Fragment fragment = fragmentManager.findFragmentByTag(tag);
Fragment fragment = fragmentManager.findFragmentById(id);
获取到 Fragment 之后就可以调用 Fragment 的方法。也就实现了通信功能。
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2;
//Options 只保存图片尺寸大小，不保存图片到内存
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inSampleSize = 2;
Bitmap bmp = null;
bmp = BitmapFactory.decodeResource(getResources(),
mImageIds[position],opts);
//回收
bmp.recycle();
以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出
方法 2：对图片采用软引用，及时地进行 recyle()操作
SoftReference<Bitmap> bitmap = new SoftReference<Bitmap>(pBitmap);
if(bitmap != null){
if(bitmap.get() != null && !bitmap.get().isRecycled()){
bitmap.get().recycle();
bitmap = null;
}
}
2、界面切换导致 OOM
有时候我们会发现这样的问题，横竖屏切换 N 次后 OOM 了。
2.1、看看页面布局当中有没有大的图片，比如背景图之类的。
去除 xml 中相关设置，改在程序中设置背景图（放在 onCreate()方法中）：
Drawable drawable = getResources().getDrawable(R.drawable.id);
ImageView imageView = new ImageView(this);
imageView.setBackgroundDrawable(drawable);
在 Activity destory 时注意，drawable.setCallback(null); 防止 Activity 得不到及时的释放.
2.2 、 跟 上 面 方 法 相 似 ， 直 接 把 xml 配 置 文 件 加 载 成 view 再 放 到 一 个 容 器 里 ， 然 后 直 接 调 用
this.setContentView(View view);方法，避免 xml 的重复加载。
2.3、 在页面切换时尽可能少地重复使用一些代码
比如：重复调用数据库，反复使用某些对象等等......
常见的内存使用不当的情况
3、查询数据库没有关闭游标 查询数据库没有关闭游标 查询数据库没有关闭游标
程序中经常会进行查询数据库的操作，但是经常会有使用完毕 Cursor 后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会出现内存问题，这样就会给以后的测试和问题排查带来困难和风险。
4、构造 Adapter Adapter Adapter 时，没有使用缓存的 没有使用缓存的 没有使用缓存的convertView convertView convertView
在使用 ListView 的时候通常会使用 Adapter，那么我们应该尽可能的使用 ConvertView。
5、Bitmap 对象不再使用时调用 对象不再使用时调用 对象不再使用时调用 recycle() recycle() recycle()释放内存.
有时我们会手工的操作 Bitmap 对象，如果一个 Bitmap 对象比较占内存，当它不再被使用的时候，可以调用Bitmap.recycle()方法回收此对象的像素所占用的内存，但这不是必须的，视情况而定。
6、其他
Android 应用程序中最典型的需要注意释放资源的情况是在 Activity 的生命周期中，在 onPause()、onStop()、onDestroy()方法中需要适当的释放资源的情况。
@Override
public void onCreate() {
super.onCreate();
Thread.setDefaultUncaughtExceptionHandler(this);
}
@Override
public void uncaughtException(final Thread thread, final Throwable ex) {
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
System.out.println(Thread.currentThread());
Toast.makeText(getApplicationContext(), "thread="+thread.getId()+"
ex="+ex.toString(), 1).show();
Looper.loop();
}
}).start();
SystemClock.sleep(3000);
android.os.Process.killProcess(android.os.Process.myPid());
}
}
注意：上面的代码只是简单的将异常打印出来。
在 onCreate 方法中我们给 Thread 类设置默认异常处理 handler，如果这句代码不执行则一切都是白搭。
在 uncaughtException 方法中我们必须新开辟个线程进行我们异常的收集工作，然后将系统给杀死.
3、在 AndroidManifest 中配置该 Application
<application
android:name="com.example.uncatchexception.MyApplication"/>
由 ViewRoot 对象的 performTraversals()方法调用 draw()方法发起绘制该 View 树，值得注意的是每次发起绘
图时，并不会重新绘制每个 View 树的视图，而只会重新绘制那些“需要重绘”的视图，View 类内部变量包含了一个
标志位 DRAWN，当该视图需要重绘时，就会为该 View 添加该标志位。
Handler 机制
Android 中主线程也叫 UI 线程，那么从名字上我们也知道主线程主要是用来创建、更新 UI 的，而其他耗时操作，比如网络访问，或者文件处理，多媒体处理等都需要在子线程中操作，之所以在子线程中操作是为了保证 UI 的流畅程度，手机显示的刷新频率是 60Hz，也就是一秒钟刷新 60 次，每 16.67 毫秒刷新一次，为了不丢帧，那么主线程处理代码最好不要超过 16 毫秒。当子线程处理完数据后，为了防止 UI 处理逻辑的混乱，Android 只允许主线程修改 UI，那么这时候就需要 Handler 来充当子线程和主线程之间的桥梁了。我们通常将 Handler 声明在 Activity 中，然后覆写 Handler 中的 handleMessage 方法,当子线程调用handler.sendMessage()方法后 handleMessage 方法就会在主线程中执行。这里面除了 Handler、Message 外还有隐藏的 Looper 和 MessageQueue 对象。
在主线程中 Android 默认已经调用了 Looper.preper()方法，调用该方法的目的是在 Looper 中创建MessageQueue 成员变量并把 Looper 对象绑定到当前线程中。当调用 Handler sendMessage（对象）方法的时候就将 Message 对象添加到了 Looper 创建的 MessageQueue 队列中，同时给 Message 指定了 target 对象，其实这个 target 对象就是 Handler 对象。主线程默认执行了Looper.looper（）方法，该方法从 Looper 的成员变量MessageQueue 中取出 Message，然后调用 Message 的 target 对象的 handleMessage()方法。这样就完成了整个消息机制。
事件分发中的 2.1 事件分发中的 onTouch onTouch onTouch 和 onTouchEvent onTouchEvent onTouchEvent 有什么区别，又该如何使用？
这两个方法都是在 View 的 dispatchTouchEvent 中调用的onTouch 优先于 onTouchEvent 执行。如果在onTouch 方法中通过返回 true 将事件消费掉，onTouchEvent 将不会再执行。
另外需要注意的是，onTouch 能够得到执行需要两个前提条件，第一 mOnTouchListener 的值不能为空，第二当前点击的控件必须是 enable 的。因此如果你有一个控件是非 enable 的，那么给它注册 onTouch 事件将永远得不到执行。对于这一类控件，如果我们想要监听它的 touch 事件，就必须通过在该控件中重写 onTouchEvent 方法来实现。
讲一下android中进程的优先级？
前台进程
可见进程
服务进程
后台进程
空进程
Map、Set、List、Queue、Stack的特点与用法。
Collection 是对象集合， Collection 有两个子接口 List 和 Set
List 可以通过下标 (1,2..) 来取得值，值可以重复。
而 Set 只能通过游标来取值，并且值是不能重复的。
ArrayList ， Vector ， LinkedList 是 List 的实现类。
ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的。
LinkedList 是线程不安全的，底层是由链表实现的。
Map 是键值对集合：
HashTable 和 HashMap 是 Map 的实现类。
HashTable 是线程安全的，不能存储 null 值。
HashMap 不是线程安全的，可以存储 null 值。
Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。
Queue接口：提供了几个基本方法，offer、poll、peek等。已知实现类有LinkedList、PriorityQueue等。
21.Java中==和equals的区别，equals和hashCode的区别
java中的数据类型，可分为两类：
a. 基本数据类型：byte short long int char double boolean float .它们之间的比较应当用（＝＝），比较的是他们的值。
b. 复合数据类型(类) :当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
equals方法：
JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
hashCode 方法：
如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。
从而在集合操作的时候有如下规则：
将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。
<ViewStub
android:id="@+id/view_stub"
android:layout="@layout/profile_extra"
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
public void onMoreClick() {
ViewStub viewStub = (ViewStub) findViewById(R.id.view_stub);
if (viewStub != null) {
View inflatedView = viewStub.inflate();
editExtra1 = (EditText) inflatedView.findViewById(R.id.edit_extra1);
editExtra2 = (EditText) inflatedView.findViewById(R.id.edit_extra2);
editExtra3 = (EditText) inflatedView.findViewById(R.id.edit_extra3);
}
}
这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。
1.CharSequence是一个java接口，代表一个char序列，String、StringBuilder、StringBuffer都实现了该接口，CharSequence实例通过调用toString方法可转化为String对象。
2.String类是final的，不可派生子类，其内部封装的是char[]，另外，android下的String类和jdk中的String类是有区别的，android下的String类中部分API通过native方法实现，效率相对高一些。
3.String使用'+'进行字符串拼接时，在编译期会转化为StringBuilder#append方式
4.String在内存中有一个常量池，两个相同的串在池中只有一份实例(String s = "abc"方式或者String#intern方式会在池中分配)，使用new String方式会在heap中分配，每次创建都是一个全新的实例。
5.StrigBuilder & StringBuffer都是可扩展的串，提供了一系列apped方法用于拼接不同类型对象
6.StringBuffer于jdk1.0引入，线程安全（多线程场景下使用），StringBuilder于jdk1.5引入，线程不安全，因而效率更高。
7.StringBuilder & StringBuffer初始容量都为16，开发者应该指定其容量，以避免多次扩容所带来的性能问题。
复用convertView
使用ViewHolder
滑动时不加载图片
Item中有图片时 异步加载 并且对图片进行适当压缩
分批，分页加载
对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：
a)在运行时判断任意一个对象所属的类；
b)在运行时构造任意一个类的对象；
c)在运行时判断任意一个类所具有的成员变量和方法；
d)在运行时调用任意一个对象的方法；生成动态代理。
1.查询数据库没有关闭游标
这个是考静态内部类和非静态内部类的主要区别之一。非静态内部类会隐式持有外部类的引用，就像大家经常将自定义的adapter在Activity类里，然后在adapter类里面是可以随意调用外部activity的方法的。当你将内部类定义为static时，你就调用不了外部类的实例方法了，因为这时候静态内部类是不持有外部类的引用的。声明ViewHolder静态内部类，可以将ViewHolder和外部类解引用。大家会说一般ViewHolder都很简单，不定义为static也没事吧。确实如此，但是如果你将它定义为static的，说明你懂这些含义。万一有一天你在这个ViewHolder加入一些复杂逻辑，做了一些耗时工作，那么如果ViewHolder是非静态内部类的话，就很容易出现内存泄露。如果是静态的话，你就不能直接引用外部类，迫使你关注如何避免相互引用。 所以将 ViewHolder内部类 定义为静态的，是一种好习惯.
Java的内存管理就是对象的分配和释放问题。（两部分）
分配 ：内存的分配是由程序完成的，程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。
释放 ：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。
java把内存分两种：一种是栈内存，另一种是堆内存
1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；
2。堆内存用来存放由new创建的对象和数组以及对象的实例变量 在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理.
堆和栈的优缺点
堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。
缺点就是要在运行时动态分配内存，存取速度较慢； 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。
另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
（问题一：什么叫垃圾回收机制？）
垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。
（问题二：java的垃圾回收有什么特点？）
JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。
（问题四：什么样的对象符合垃圾回收条件？） 当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。
（问题五：垃圾回收器是怎样工作的？）
垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而Java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。
（问题六：一个java程序能够耗尽内存吗？） 可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。
（问题七：如何显示的使对象符合垃圾回收条件？） （1） 空引用 ：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。
StringBuffer sb = new StringBuffer("hello");
System.out.println(sb);
sb=null;
（2） 重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("goodbye");
System.out.println(sb1);
sb1=sb2;//此时"hello"符合回收条件
（3） 方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。
public static void main(String[] args) {
Date d = getDate();
System.out.println("d = " + d);
}
private static Date getDate() {
Date d2 = new Date();
StringBuffer now = new StringBuffer(d2.toString());
System.out.println(now);
return d2;
}
（4） 隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。
public class Island {
Island i;
public static void main(String[] args) {
Island i2 = new Island();
Island i3 = new Island();
Island i4 = new Island();
i2.i=i3;
i3.i=i4;
i4.i=i2;
i2=null;
i3=null;
i4=null;
}
}
如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！
