2024年Android--关闭某个指定activity，腾讯秋招几面

本文链接：https://blog.csdn.net/2401_84519718/article/details/138807395

如何做好面试突击，规划学习方向？

面试题集可以帮助你查漏补缺，有方向有针对性的学习，为之后进大厂做准备。但是如果你仅仅是看一遍，而不去学习和深究。那么这份面试题对你的帮助会很有限。最终还是要靠资深技术水平说话。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。建议先制定学习计划，根据学习计划把知识点关联起来，形成一个系统化的知识体系。

学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。

同时我还搜集整理2020年字节跳动，以及腾讯，阿里，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

public static AActivity getInstance() {
if (sInstance != null) {
return sInstance;
}
return null;
}
public static void finishActivity() {
if (sInstance != null) {
sInstance.finish();
}
}

内存泄漏明显，之所以有但是，那是因为这种方式让我想到加入弱引用WeakReference的方式。

public class BActivity extends BaseActivity {
private static WeakReference sActivityRef;
public static void finishActivity() {
if (sActivityRef != null && sActivityRef.get() != null) {
sActivityRef.get().finish();
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
sActivityRef = new WeakReference<>(this);
Button btnB = (Button) findViewById(R.id.btn_b);
btnB.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(BActivity.this, CActivity.class));
}
});
}
}

WeakReference以及JVM相关，虽然WeakReference被static了，生命周期变长了，但是WeakReference关联的对象不受影响的，依然遵循WeakReference在gc时候的规则。
优劣：优点：代码简单直观，引入WeakReference，解决了内存泄漏问题。缺点：在每个activity中都要添加，代码量多。（不知是否可抽取到基类中，以后尝试）
##方案三
####使用集合或者栈的方式

public class FinishActivityManager {
private FinishActivityManager() {
}
private static FinishActivityManager sManager;
private List activityList;
public static FinishActivityManager getManager() {
if (sManager == null) {
synchronized (FinishActivityManager.class) {
if (sManager == null) {
sManager = new FinishActivityManager();
}
}
}
return sManager;
}
/**

添加Activity到集合中
/
public void addActivity(Activity activity) {
if (activityList == null) {
activityList = new LinkedList<>();
}
activityList.add(activity);
}
/*
关闭指定的Activity
/
public void finishActivity(Activity activity) {
if (activityList != null && activity != null && activityList.contains(activity)) {
//使用迭代器安全删除
for (Iterator it = activityList.iterator(); it.hasNext(); ) {
Activity temp = it.next();
// 清理掉已经释放的activity
if (temp == null) {
it.remove();
continue;
}
if (temp == activity) {
it.remove();
}
}
activity.finish();
}
}
/*
关闭指定类名的Activity
/
public void finishActivity(Class<?> cls) {
if (activityList != null) {
// 使用迭代器安全删除
for (Iterator it = activityList.iterator(); it.hasNext(); ) {
Activity activity = it.next();
// 清理掉已经释放的activity
if (activity == null) {
it.remove();
continue;
}
if (activity.getClass().equals(cls)) {
it.remove();
activity.finish();
}
}
}
}
/*
关闭所有的Activity
/
public void finishAllActivity() {
if (activityList != null) {
for (Iterator it = activityList.iterator(); it.hasNext(); ) {
Activity activity = it.next();
if (activity != null) {
activity.finish();
}
}
activityList.clear();
}
}
/*
退出应用程序
*/
public void exitApp() {
try {
finishAllActivity();
// 退出JVM,释放所占内存资源,0表示正常退出
System.exit(0);
// 从系统中kill掉应用程序
android.os.Process.killProcess(android.os.Process.myPid());
} catch (Exception e) {
e.printStackTrace();
}
}
}

这种方式注意在删除的时候使用迭代器，否则会出现并发修改异常。那就来说说但是，应用中要是不使用这种封装的方式去finish掉Activity的时候，封装的manager并不知道，没有断开并释放掉其引用，会引起内存泄漏。所以WeakReference又要出场了。

public class FinishActivityManager {
private FinishActivityManager() {
}
private static FinishActivityManager sManager;
private Stack<WeakReference> mActivityStack;
public static FinishActivityManager getManager() {
if (sManager == null) {
synchronized (FinishActivityManager.class) {
if (sManager == null) {
sManager = new FinishActivityManager();
}
}
}
return sManager;
}
/**

添加Activity到栈
@param activity
/
public void addActivity(Activity activity) {
if (mActivityStack == null) {
mActivityStack = new Stack<>();
}
mActivityStack.add(new WeakReference<>(activity));
}
/*
检查弱引用是否释放，若释放，则从栈中清理掉该元素
/
public void checkWeakReference() {
if (mActivityStack != null) {
// 使用迭代器进行安全删除
for (Iterator<WeakReference> it = mActivityStack.iterator(); it.hasNext(); ) {
WeakReference activityReference = it.next();
Activity temp = activityReference.get();
if (temp == null) {
it.remove();
}
}
}
}
/*
获取当前Activity（栈中最后一个压入的）
@return
/
public Activity currentActivity() {
checkWeakReference();
if (mActivityStack != null && !mActivityStack.isEmpty()) {
return mActivityStack.lastElement().get();
}
return null;
}
/*
关闭当前Activity（栈中最后一个压入的）
/
public void finishActivity() {
Activity activity = currentActivity();
if (activity != null) {
finishActivity(activity);
}
}
/*
关闭指定的Activity
@param activity
/
public void finishActivity(Activity activity) {
if (activity != null && mActivityStack != null) {
// 使用迭代器进行安全删除
for (Iterator<WeakReference> it = mActivityStack.iterator(); it.hasNext(); ) {
WeakReference activityReference = it.next();
Activity temp = activityReference.get();
// 清理掉已经释放的activity
if (temp == null) {
it.remove();
continue;
}
if (temp == activity) {
it.remove();
}
}
activity.finish();
}
}
/*
关闭指定类名的所有Activity
@param cls
*/
public void finishActivity(Class<?> cls) {
if (mActivityStack != null) {