En Android, el almacenamiento de datos se divide en dos formas:
1. Almacenar directamente en el directorio como un archivo
2. Almacenar en la base de datos en formato json
Hay dos formas de almacenar datos en archivos:
1. Genere un archivo .txt
2. Generar archivo xml
Entonces, hoy, hablemos en detalle sobre el almacenamiento en forma de archivos. Dado que no se menciona la base de datos, hablaremos sobre el almacenamiento en la base de datos en formato json en cursos posteriores.
1. Genere un archivo .txt
La generación de archivos no es más que una parte de los flujos de entrada y salida que aprendemos en Java. Creo que es fácil de entender con una base de Java, porque es realmente simple~~
1. El directorio generado se puede dividir en dos tipos:
1) nativo
2) tarjeta SD
2. Hay cuatro formas de generar archivos .txt
1) Use el modo MODE_PRIVATE para generar un archivo privado
2) Use el modo MODE_PRIVATE para generar un archivo adjunto
3) Use el modo MODE_WORLD_READABLE para generar un archivo legible
4) Use el modo MODE_WORLD_WRITEABLE para generar un archivo grabable
Antes de generar un archivo .txt, debemos comprender los permisos del archivo, como se muestra a continuación:
1. La primera celda: indica el tipo de archivo
2. Casilla 2-4: Indica los permisos del usuario actual
3. Casilla 5-7: Indica los permisos del grupo al que pertenece el usuario actual
4. Casillas 8-10: Indique los permisos que poseen otros usuarios
5. "r": significa legible; "w": significa escribible; "x": significa ejecutable; "-": significa sin permiso, si ve "rwx", significa legible, escribible y ejecutable, y otras combinaciones
Nota: Los permisos de los archivos generados por diferentes modos son diferentes, y los permisos de los tipos de archivos generados también son diferentes.
Luego, estos métodos se describirán en detalle a continuación.
1. Como se muestra en la figura, cuando hacemos clic en el botón, se activa el monitoreo del archivo. El botón aquí es un botón simple, pero recuerde establecer el atributo del evento de clic en clic ~ No todos son estúpidos, ¿verdad? ..
1) Use el modo MODE_PRIVATE para generar un archivo privado
//Haga clic en el botón 1 y use el modo MODE_PRIVATE para generar un archivo privado
public void click1(Ver v){
try {
FileOutputStream fos = openFileOutput("private.txt", MODE_PRIVATE);
fos.write("private".getBytes() ) ;
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
2) Use el modo MODE_PRIVATE para generar un archivo adjunto
//Haga clic en el botón 2 y use el modo MODE_PRIVATE para generar un archivo adjunto
public void click2(Ver v){
try {
FileOutputStream fos = openFileOutput("appent.txt", MODE_PRIVATE);
fos.write("appent".getBytes()) ;
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
3) Use el modo MODE_WORLD_READABLE para generar un archivo legible
//Haga clic en el botón 3 para usar el modo MODE_WORLD_READABLE para generar un archivo legible
public void click3(Ver v){
try {
FileOutputStream fos = openFileOutput("readable.txt", MODE_WORLD_READABLE);
fos.write("readable".getBytes()) ;
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
4) Use el modo MODE_WORLD_WRITEABLE para generar un archivo grabable
//Haga clic en el botón 4 y use el modo MODE_WORLD_WRITEABLE para generar un archivo de escritura
public void click4(View v){
try {
FileOutputStream fos = openFileOutput("writeable.txt", MODE_WORLD_WRITEABLE);
fos.write("writeable".getBytes()) ;
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
Parte de la descripción del código.
FileOutputStream: flujo de salida de archivos
openFileOutput("private.txt", MODE_PRIVATE): openFileOutput es el flujo de salida del archivo empaquetado en Android, private.txt es el nombre del archivo generado y MODE_PRIVATE es el modo mencionado anteriormente.
fos.write("private".getBytes()): escribir es qué escribir, el parámetro aquí es el contenido de texto que desea escribir, getBytes()…………… ^_^ No sé leer Java por mí mismo Conceptos básicos jajaja~~~
close(): cerrar el objeto de flujo
try-catch: Hay una excepción, inténtalo...
MODE_WORLD_WRITEABLE, MODE_WORLD_READABLE: estos dos modos han quedado obsoletos... ¡no tanto por qué! Jajaja……
Me siento lindo... Si realmente no sabes cómo hacerlo, ¡repasemos los conceptos básicos de Java!
Entonces aquí hay 4 archivos como se muestra en la figura a continuación
2. Guarde el archivo en la tarjeta SD
1. Obtenga la ruta de la tarjeta SD:
String sdPath = Environment.getExternalStorageDirectory().getPath() ;
2. Agregar ruta
Archivo archivo = nuevo archivo (sdPath + "writeable.txt");
¡Entonces escribe la ruta así! Es así de simple
3. Lea el archivo que acaba de escribir.
Al leer el contenido del archivo, ¿cuál es la ruta que escribe, luego cuál es la ruta al leer?
intente {
//Archivo archivo = nuevo archivo("/data/data/com.test.filereadwrite/files/readable.txt");
Archivo archivo = nuevo archivo("/data/data/com.test.filereadwrite/files/writeable.txt");
FileInputStream fis = new FileInputStream(archivo);
BufferedReader bffr = new BufferedReader(new InputStreamReader(fis));
Contenido de la cadena = bffr.readLine();
Toast.makeText(MainActivity.this, content, 2000).show();
} catch (Excepción e) {
e.printStackTrace();
}
4. Optimización de la ruta
Todos han descubierto que estoy escribiendo directamente la ruta aquí, por lo que esta forma de escribir no es óptima, entonces, ¿cómo se puede optimizar más?, solo cambie dos líneas de código durante mucho tiempo, por ejemplo: 1.
Obtener ruta:
Cadena ruta = Contexto.getFilesDir().getPath();
2. Agregue la ruta:
Archivo archivo = nuevo Archivo (ruta + "escribible.txt");
Nota: Las rutas que escribimos deben optimizarse de esta manera y no deben escribirse hasta la muerte. Aquí estoy tratando de asustar a los monos jajaja~ Así que lo escribí hasta la muerte... pero el efecto es el mismo~~
Segundo, genera el archivo xml
La generación de archivos xml se puede dividir en dos formas:
1. Usar StringBuffer nativo para unir archivos xml
2. Usar la clase XmlPullParser empaquetada de Android
para generar archivos xml es lo mismo, pero personalmente prefiero el segundo método porque es simple, es simple , tan simple que los ingenieros de Google no necesitan escribir códigos de ejemplo en los documentos de desarrollo...
Antes de generar xml, no olvide escribir una clase de entidad, de lo contrario, ¿cómo encapsula los datos? Dígame cómo encapsular...
Luego agregaremos directamente el código aquí (escriba la clase de entidad usted mismo...)
@Override
protected void onCreate(Bundle SavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Inicializar los datos que queremos respaldar
smsLists = new ArrayList<Sms>();
//Insertar prueba datos
para (int i = 0; i < 10; i++) {
Sms sms = new Sms();
sms.setAddress("10086"+i);
sms.setBody("Hello"+i);
sms.setDate(" 201 "+i);
//añadir el objeto sms a la colección
smsLists.add(sms);
}
}
1. Use StringBuffer nativo para unir archivos xml
agregar("<cuerpo>");
sb.append(sms.getBody());
imprimirSeguimientoPila();
//Ensamblar nodo de fecha
sb.append("<date>");
sb.append(sms.getDate());
sb.append("</date>");
sb.append("</sms>" ) ;
}
// fin del nodo smss
sb.append("</smss>");
// Guardar datos en la tarjeta SD
intente {
Archivo archivo = nuevo archivo (Environment.getExternalStorageDirectory().getPath(),"smsbackup. xml") ;
FileOutputStream fos = new FileOutputStream(archivo);
fos.write(sb.toString().getBytes());
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
2. Use la clase XmlPullParser empaquetada de Android
//Haga clic en el botón button2 para generar un archivo xml a través de XmlSerializer
public void click2(View v){
try {
//Obtenga una instancia de la clase XmlSerializer y obtenga el XmlSerializer a través de la herramienta xml class
serializer = Xml.newSerializer();
/ /Establecer parámetro de serialización de XmlSerializer
File file = new File(Environment.getExternalStorageDirectory().getPath(),"smsbackup.xml");
FileOutputStream fos = new FileOutputStream(file);
serializer.setOutput(fos,"utf-8");
// Comience a escribir el comienzo del documento xml
serializer.startDocument("utf-8", true);
//escriba el espacio de nombres del espacio de nombres del nodo raíz de xml
serializer.startTag(null, "smss");
//atraviese los nodos de sms y nodos secundarios
for (Sms sms : smsLists ) {
serializador.startTag(nulo, "sms");
//组拼addressa节点
serializer.startTag(null, "address");
serializador.text(sms.getAddress());
serializer.endTag(nulo, "dirección");
//组拼body节点
serializer.startTag(null, "body");
serializador.texto(sms.getBody());
serializer.endTag(nulo, "cuerpo");
//组拼date节点
serializer.startTag(null, "fecha");
serializador.texto(sms.getDate());
serializer.endTag(nulo, "fecha");
serializador.endTag(nulo, "SMS");
}
serializer.endTag(null, "smss");
//finalizar xml end
serializer.endDocument();
//cerrar secuencia
fos.close();
} catch (Excepción e) {
e.printStackTrace();
}
}
Luego, el archivo xml como se muestra a continuación se genera aquí: 3. Lea los datos en el archivo xml
@Override
protected void onCreate(Bundle SavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
try {
//Mostrar información de datos
TextView tv_sms = (TextView) findViewById(R.id.tv_weather);
// Obtén el administrador del activo a través del contexto
InputStream in = getAssets().open("smss.xml");
//Llama al método comercial que definimos para analizar xml
List<Sms> smsLists = SmsParser.xmlParser(in);
StringBuffer sb = new StringBuffer();
for (Sms sms : smsLists) {
sb.append(sms.toString());
}
//Mostrar datos en TextView
tv_sms.setText(sb.toString());
} catch (Excepción e) {
e.printStackTrace();
}
}
Parte de la descripción del código:
Aquí quiero enseñarte cómo leer los documentos de desarrollo por ti mismo... Así que vamos a los documentos de desarrollo por ti mismo... Jajaja~~
pd: Aquí quiero explicar que no es que yo No sé cómo ser perezoso, pero todos podrán ver los documentos de desarrollo cuando la empresa se desarrolle en el futuro y, para ser honesto, hay muchas cosas en Android, simplemente es demasiado difícil recordar todo. ellos... así que espero que
todos puedan aprender a ver los documentos de desarrollo por sí mismos... Esto puede ser considerado como un curso obligatorio para mí ~~ Porque para mí, que soy un novato, aprender a leer documentos me ahorrará mucho problemas, como que de repente hay algo que no puedo... ¿Qué debo hacer? Jajaja...
3. Resumen
1. 4 métodos y pasos para generar archivos .txt
2. 2 métodos y pasos para generar archivos xml
3. Leer archivos .txt
4. Leer archivos xml
5. Almacenar datos en este 6.
Aprende a leer documentos de desarrollo
7. Permisos de archivo