60 technical experiences summarized in daily Android development

[[181259]]

1. All Activities can inherit from BaseActivity, which is convenient for unifying styles and handling common events, and building a unified builder for dialog boxes. In case of overall changes, one modification will be effective everywhere.

2. The database table segment field constants and SQL logic are separated, which is clearer. It is recommended to use the LiteOrm library of the Lite series framework, which is super clear and allows you to focus on the business without worrying about database details.

3. Put global variables in the global class, and put module private variables in their own management class to make constants clear and centralized.

4. Don't believe that huge management things will bring any benefits, it may be a disaster. Always pay attention to the single responsibility principle. It is clearer for a class to concentrate on doing one thing well.

5. If the data does not need to be loaded, please be sure to delay initialization of the data. Remember to save memory for users, it will never hurt.

6. When an exception is thrown, it should be handled at the appropriate location or in a centralized manner. Do not have catch methods everywhere, which will cause confusion and low performance. Try not to catch exceptions in the loop body to improve performance.

7. When the address reference chain is long (more than 3 pointers), be careful of memory leaks and be alert to stack address pointing. A typical event is: the data is updated, but the ListView view is not refreshed. At this time, the Adapter is likely to point to the address of the data container (usually List) that you updated.

8. Information synchronization: Regardless of whether it is a database or network operation, pay attention to returning the ID of the newly inserted data (if no unique ID is assigned), otherwise it is equivalent to no synchronization.

9. When operating the database with multiple threads, an error will be reported if the db is closed, and interlocking problems are likely to occur. It is recommended to use transactions and automated LiteOrm library operations.

10. Before doing anything, consider those resources, layouts, and classes that can be shared, and do a structure and architecture analysis to speed up development and improve code reusability.

11. When performing add and delete operations on ordered queues, be sure to maintain the order, otherwise you will be embarrassed.

12. When deleting data in the database, pay attention to cascading operations to avoid dirty data that can never be deleted.

13. About formal parameters and actual parameters: When calling a function, if the parameter is a basic type, what is passed is the value; if the parameter is an object, what is passed is a reference.

14. When the data in listview does not fill one screen, the setSelection function does not work; when ListView is operated in batches, each sub-item and view corresponds correctly, and the visible one is selected.

15. Control the amount of Activity code and keep the main logic clear. Other classes should comply with the SRP (single responsibility) and ISP (interface isolation) principles.

16. When executing remove in arraylist, pay attention to the difference between removing int and Integer. You know.

17. Please add tags to the log. Debug printing must be marked so that the printing position can be located. Otherwise, it will be embarrassing: you will not know where it is printing.

18. Code blocks/constants/resources that can be centralized and shared should be shared. Even if the shared logic is a little complicated, it will be worthwhile and easy to modify. Modify one and it will be effective everywhere.

19. setSelection does not work, try smoothScrollToPosition. The LastVisiblePosition (last visible item) of ListView will change with the different execution positions of the getView method.

20. It is more convenient to use Handler to communicate with Activity; if your framework callback chain becomes longer, consider the listener pattern to simplify the callback.

21. When the listener mode is not convenient to use, the EventBus framework library is recommended, which uses the time bus. Students who have not been exposed to it can use their imagination to fill in the gaps.

22. The Handler uses Looper.prepare in the child thread, or passes the MainLooper to the constructor when new to ensure that it runs in the main thread.

23. After clicking OK on the timepicker, you need to clearFocus to get the manually entered time.

24. It is highly recommended not to start an asynchronous thread in the constructor, as it will cause hidden dangers. For example, if an asynchronous thread calls the example in this example, it will crash tragically.

25. Never take it for granted that an object will not be null, and make full fault tolerance. Also note that null can also be inserted into containers such as ArrayList.

26. The child list of ExpandableListView cannot be clicked (disabled). Return the isChildSelectable method of Adapter to true.

27. When the UI displays content that is too long, use ScrollView in advance, otherwise it will be awkward on a small phone.

28. Make sure the sensing range of the button is not less than 9mm, otherwise it will be difficult to click; pay attention to the position of the cursor in the input box to make it easier for users to input.

29. The server and client should use a unified unique identifier (possibly an ID) as much as possible, otherwise there will be some ambiguity and problems.

30. Comments: Try to write enough comments to describe your ideas so that you can understand a piece of code.

31. Sqlite Transaction must be used for complete data and big data. A rough test shows that inserting 100 data items speeds up by 20 times, and inserting 1,000 data items speeds up by more than 100 times.

32. Avoid the situation where String = "null". Both String = null and "" are acceptable. Avoid submitting data such as title = "No subject" to the database to waste space.

33. When there are multiple different dbhelper instances, there must be different instances of the sqlitedatabase object. When multiple threads write data at the same time, they will report db is locked from time to time when writing data in turn, causing a crash, regardless of whether they are operating the same table or different tables. Reading and writing can be concurrent at the same time, and they are executed in turns without regularity. When writing data at the same time, the solution is to use transactions for each concurrent thread, and the db will not lock and write as a whole in batches.

34. It is recommended that the entire application maintain a dbhelper instance. As long as the db is not closed, there is only one db instance globally. Multiple threads concurrently writing to the db will not lock it, and writing is strictly alternating: 123123123... (123 represents different threads, which take turns inserting a record). Neither reading nor writing will lock the db. There is no regular alternation between reading and writing. The number and degree of execution depends on the length of the time slice allocated to which thread by the cpu.

35. A task uses transactions to nest N transactions. If one of the N transactions fails, the entire task fails. Data is written only after all transactions succeed, which is safe and holistic. In addition, the efficiency of transactions writing large batches of data is hundreds or thousands of times higher than that of general single writing after actual testing. For large amounts of database data and multi-threaded operations, it is recommended to use the LiteOrm database framework, which is more stable and simple.

36. You often need to use ListView or other controls that display a large number of items to track or view information in real time, and hope that the most important items can be automatically scrolled to the visible range. By setting the transcriptMode property of the control, you can automatically slide the Android platform control (supporting ScrollBar) to the top.

37. Long a; Check if a has a value. if(a == 0) will report an error if a has no value. It should be if(a == null). The same applies to Integer, Floag, etc. You know the reason. I just want to remind you to be careful.

38. When encoding, the logic of reading, writing, input and output must be considered in both directions. File import and export, and character byte conversion must be transcoded on both sides.

39. The size ratio of an int value to an Integer object (the smallest object that can contain an int value) is about 1:4 (32-bit and 64-bit machines are different). The additional overhead comes from the metadata that the JVM uses to describe Java objects, which is Integer (Long, Double, etc.).

40. Objects consist of metadata and data. Metadata includes class (pointer to class, describing the class type), tag (describing the object status, such as hash code, shape, etc.), lock (object synchronization information). Array objects also include size metadata.

41. A Java application that uses a 1GB Java heap in a 32-bit Java runtime typically needs to use a 1.7GB Java heap after being migrated to a 64-bit Java runtime.

42. Hash collections have higher access performance than any List, but the cost per entry is also higher. Due to access performance reasons, if you are creating a large collection (for example, for implementing a cache), it is best to use a Hash-based collection without having to consider the additional overhead.

43. List is a reasonable choice for smaller collections where access performance is not so important. The performance of ArrayList and LinkedList collections is roughly the same, but their memory footprint is completely different: ArrayList's per-entry size is much smaller than LinkedList, but it is not exactly sized. The correct implementation of List to use, ArrayList or LinkedList, depends on the predictability of the List's length. If the length is unknown, then the right choice may be LinkedList because the collection contains less empty space. If the size is known or predictable or relatively small, then ArrayList's memory overhead will be lower.

43. Choosing the right collection type allows you to strike a reasonable balance between collection performance and memory usage. In addition, you can minimize memory usage by properly sizing the collection to maximize fill rate and minimize unused space.

44. Make full use of the concepts of encapsulation (providing interface classes to control access to data) and delegation (helper objects to implement tasks).

45. Delayed allocation of Hashtable: If it is common for the Hashtable to be empty, it is reasonable to allocate the Hashtable only when there is data to be stored. Allocate the Hashtable to the exact size: Although there is a default size, it is recommended to use a more accurate initial size.

46. ​​Don't forget to setSelection when setting Text in EditText. In most cases, it is necessary to set it.

47. Pay attention to two situations in XML: 1. There are duplications in attribute names; 2. Pay attention to whether the text contains illegal characters and pay attention to using CDATA wrapping.

48. When there are no obvious problems with the logic, consider whether the object properties, function parameters, and network transmission parameters are all understood and set correctly.

49. When compilation or runtime errors occur and others have no problems, consider whether there are problems with your compilation environment and environment version.

50. Due to the immutable nature of the String class, when a String variable needs to change its value frequently, you should consider using StringBuilder to improve performance, and using StringBuffer in multiple threads to operate strings to improve program efficiency.

51. The advantage of the Java stack is that it is faster than the heap and can be shared. It is mainly used to store temporary variables and parameters. The advantage of the heap is that the memory size can be dynamically allocated.

52. Whenever a new object is created using new(), it will be created in the heap, and its data will be stored separately. Even if the data (value) is the same as the data in the stack, it will not be shared with the data in the stack.

53. Variables defined with basic data types are called automatic variables. They store "literal values", exist in the stack, and can be shared (if they exist, they will not be created).

54. Multiple RandomAccessFile objects point to the same file, and multiple threads can be used to write together without locking. The test conclusion is: three threads write 1 million times of data respectively, it takes about 12 seconds to use the lock and about 8.5 seconds without using the lock. 100 threads write 10,000 times of data respectively, it takes about 4.2 seconds to use the lock and about 3 seconds without using the lock.

55. Use the nextText() method with caution in XmlPullParser parsing. The XML is relatively complex and may cause abnormal problems when it contains empty tags or repeated name tags. Use the getText() method in TEXT instead of the nextText() method in START_TAG. Use the START_TAG, TEXT, and END_TAG events together. Note that the TEXT event will appear between each XML node (regardless of the start node or the end node).

56. When changing the logic, consider all the places where this function is used. If it is scattered too much, it is easy to be careless.

57. When a problem occurs with a native component of the system, check the error stack information, write a subclass of the component, and rewrite the error method in the appropriate place, and add try catch to ensure that it does not crash. Do not disrupt the normal logic of the system control.

58. Pay attention to the control of spaces, line breaks and other symbols when inputting controls; pay attention to the space between the content in the input box and the left and right controls to prevent accidental clicks.

59. Pay attention to the ++ or – operator in the function parameters. It makes a big difference whether it is ++c or c++.

60. Never underestimate the null pointer problem in any place. In some cases, it is better to kill by mistake (try catch) than to let it go.