精华内容
下载资源
问答
  • 在程序的运行过程中,我们往往需要保存一定的数据,以便程序在其他场合可以调取这些数据,例如:Activity的状态信息,两个Activity共享的某些数据等。我们暂且把这种功能叫做数据持久化,意如其名,用于相对持久地...

            在程序的运行过程中,我们往往需要保存一定的数据,以便程序在其他场合可以调取这些数据,例如:Activity的状态信息,两个Activity共享的某些数据等。我们暂且把这种功能叫做数据持久化,意如其名,用于相对持久地保存应用程序的数据。

            Android有四种保存应用程序数据的方式:

            1. SharedPreferences

            2. File

            3. SQLite

            4. Content Provider

            本文主要讲解SharedPreferences的基本用法。

            SharedPreferences是Android提供的保存简单的应用程序数据的类,它通过<键,值>对的方式来保存数据,也就是为需要保存的数据指定一个键,通过检索键找到数据,从而对数据进行读写。<键,值>对保存到一个XML文件中。当需要保存多个数据时,就定义多个键,分别存储。

            SharedPreferences是一种轻量级的存储类,用于保存Activity的状态,或者一些简单的数据。下面通过一个例子来学习SharedPreferences的使用方法。


            示例:建立两个Activity,一个使用SharedPreferences写入键值对,另外一个使用SharedPreferences读取这个键值对,从而实现两个Activity之间的数据共享。

            1. 使用Eclipse创建一个Android项目,命名为MyTest_SharedPreferences。

            2. 在/res/layout文件夹下,修改activity_main.xml文件,添加一个编辑框和一个按钮,编辑框用于输入需要保存的内容,单击按钮会将文本框中的内容保存下来,并跳转到读取数据的Activity。activity_main.xml的代码如下:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >
        
        <!-- 编辑框控件,id为txtString -->
        <EditText 
            android:id="@+id/txtString"			
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
        
        <!-- 按钮控件,id为btnSave,点击后触发onSave方法  -->
        <Button
            android:id="@+id/btnSave"			
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Save"
            android:onClick="onSave"/>		
    
    </LinearLayout>

            3. 在MainActivity.java中添加如下内容:

    import android.app.Activity;
    import android.content.Intent;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.EditText;
    
    public class MainActivity extends Activity {
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    	}
    	
    	//点击按钮触发onSave方法,将文本框中的内容以键值对的方式写入MyTest_SharedPreferences。xml中
    	public void onSave(View view){
    		//创建一个SharedPreferences对象appPrefs,关联的xml文件为MyTest_SharedPreferences.xml
    		//MODE_PRIVATE表示只有创建的应用程序能够打开此文件
    		SharedPreferences appPrefs = 
    				getSharedPreferences("MyTest_SharedPreferences",MODE_PRIVATE);
    		
    		//创建一个Editor对象,用于向xml文件中写数据
    		SharedPreferences.Editor prefsEditor = appPrefs.edit();	
    		
    		//获取EditText控件中的文本,保存在str中
    		String str = ((EditText)findViewById(R.id.txtString)).getText().toString();
    		
    		//使用putString函数,将键值对<SavedData,str>写入xml文件
    		prefsEditor.putString("SavedData", str);
    		
    		//通过commit方法提交数据,保存完毕
    		prefsEditor.commit();
    		
    		//跳转到ReadActivity
    		startActivity(new Intent("ReadActivity"));
    	}
    }
    
            使用SharedPreferences保存数据的步骤是:

            (1)创建SharedPreferences对象:SharedPreferences SP对象名= getSharedPreferences(xml文件名,操作模式);

            (2)创建Editor对象:SharedPreferences.Editor SP_E对象名= SP对象名.edit();

            (3)使用Editor的putString方法写入键值对:SP_E对象名.purString(键, 值);

            (4)使用Editor的commit方法提交数据:SP_E对象名.commit();

            用于保存键值对的xml文件保存在/data/data/shared_prefs文件夹下,其定义了应用程序指定的键和对应的值,想要查看此xml文件,需要有root权限。

           4. 下面创建读取数据的Activity,首先在/res/layout文件夹下新建一个xml文件,命名为readdata.xml,并添加如下内容:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >
        
        <!-- 用于显示读取数据的文本框,id为txtString2 -->
        <EditText 
            android:id="@+id/txtString2"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"/>
        
        <!-- 按钮控件,id为btnRead,点击后触发onRead方法 -->
        <Button
            android:id="@+id/btnRead"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Read"
            android:onClick="onRead"/>"
    
    </LinearLayout>
           5. 在src文件夹中添加一个类,命名为ReadActivity,并添加如下代码:

    import android.app.Activity;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.EditText;
    
    public class ReadActivity extends Activity{
    	public void onCreate(Bundle savedInstanceState){
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.readdata);
    	}
    	
    	//点击按钮触发onRead方法,将指定的键值对读取出来,并显示在文本框中
    	public void onRead(View view){
    		//创建一个SharedPreferences对象appPrefs,关联的文件为MyTest_SharedPreferences.xml
    		//MODE_PRIVATE表示只有创建的应用程序能够打开此文件
    		SharedPreferences appPrefs = 
    				getSharedPreferences("MyTest_SharedPreferences",MODE_PRIVATE);
    		
    		//将键为SavedData对应的值提取出来,并保存在str中
    		String str = appPrefs.getString("SavedData", "");
    		
    		//定义一个EditText对象et,并使之与id为txtString2的EditText控件关联
    		EditText et = (EditText)findViewById(R.id.txtString2);
    		
    		//将str的内容显示在et上
    		et.setText(str);
    	}
    }
            使用SharedPreferences读取数据的步骤是:

            (1)创建SharedPreferences对象:SharedPreferences SP对象名= getSharedPreferences(xml文件名,操作模式);

            (2)使用getString方法读取指定键的值:SP对象名.getString(键,"");

            6. 两个Activity都已经写好,下面在AndroidManifest.xml中添加ReadActivity类的条目:

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.mytest_sharedpreferences"
        android:versionCode="1"
        android:versionName="1.0" >
    
        <uses-sdk
            android:minSdkVersion="8"
            android:targetSdkVersion="19" />
    
        <application
            android:allowBackup="true"
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            <activity
                android:name="com.example.mytest_sharedpreferences.MainActivity"
                android:label="@string/app_name" >
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            <activity 
                android:label="Read Activity"
                android:name=".ReadActivity">
                <intent-filter >
                    <action android:name="ReadActivity"/>
                    <category android:name="android.intent.category.DEFAULT"/>
                </intent-filter>
            </activity>
        </application>
    
    </manifest>
    
            7. 调试应用程序,进入应用后,在文本框中输入字符串,例如:“需要保存的数据”,如下图所示:


            8. 点击Save按钮,进入ReadActivity界面,如下图所示:


            9. 点击Read,读取上一个Activity保存的数据,并显示在文本框中,如下图所示:


            SharedPreferences的使用相对简单,在需要保存数据的地方添加写入的代码,在需要读取数据的时候添加读取的代码即可,但是SharedPreferences适用于保存简单的数据,如果需要保存的数据量大,结构复杂,则需要考虑文件、数据库等其他数据保存方式。

    展开全文
  • * 基于变量(对象):可以保存多个不同类型的数据 * * 1. 可以任意添加任意类型的数据 void add(Object obj) * 2. 可以记录当前数据的个数 int size() * 3. 可以打印当前数据结构的对象 toString()...
    package linkedlist;
    
    /**
     *	基于变量(对象):可以保存多个不同类型的数据
     *			
     *				1. 可以任意添加任意类型的数据 void add(Object obj)
     *				2. 可以记录当前数据的个数 int size()
     *				3. 可以打印当前数据结构的对象 toString(),格式如下:[值1,值2.。。。。]
     *
     *				根据下标查询当前的节点对象 Node searchNodeByIndex(int index)(重要方法)
     *				
     *				4. 查询指定下标的元素  Object searchByIndex(int index)
     *				5. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
     *
     *				6. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
     *				7. 删除指定下标处的元素,返回删除的元素  	Object deleteByIndex(int index)
     *				8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
     *				9. 插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
     *					
     *				10.将对象中所有元素清空 void clear();
     *				11.创建对象,可以直接传入一个参数初始化
     */
    public class SinglyLinkedList{
    	/**保存第一个添加的元素地址*/
    	private Node first;
    	
    	/**添加的元素个数*/
    	private int size;
    	
    	public SinglyLinkedList() {
    	}
    	
    	/**
    	 * 1. 可以任意添加任意类型的数据 void add(Object obj)
    	 */
    	public void add(Object obj){
    		//添加元素
    		Node node = new Node(obj);
    		
    		//判断是否是第一次添加元素
    		if (first == null) {//表示第一次添加
    			//将创建好的Node对象node的地址给first保存
    			first = node;
    		} else {//不是第一次添加元素
    			//遍历整个链表
    			//声明一个临时变量temp专门保存遍历的Node对象
    			Node temp = first;//从头开始遍历 
    			
    			//遍历链表,判断当前遍历的Node对象next是否为null,如果是表示最后一个对象
    			while (temp.next != null) {//如果不是null,表示还有下一个
    				//将下一个的元素地址赋值给临时变量temp保存
    				temp = temp.next;
    			}
    			//循环结束后,肯定是最后一个元素
    			temp.next = node;//将先创建的地址赋值给最后一个元素的next保存
    		}
    		
    		//元素个数+1
    		size++;
    	}
    	
    	/**
    	 * 2. 可以记录当前数据的个数 int size()
    	 * @return
    	 */
    	public int size(){
    		return size;
    	}
    	
    	/**
    	 * 3. 可以打印当前数据结构的对象 toString(),格式如下:[值1,值2.。。。。]
    	 */
    	@Override
    	public String toString() {
    		//声明一个StringBuilder对象,用来拼接字符串
    		StringBuilder sb = new StringBuilder("[");
    		
    		//判断当前链表是否有元素
    		if (first == null) {//链表没有元素,就直接返回一个空[]
    			return sb.append("]").toString();
    		}
    		
    		//声明一个临时变量temp专门保存遍历的Node对象
    		Node temp = first;//从头开始遍历
    		
    		sb.append(temp.value);//拼接第一个元素的value值
    			
    		//遍历链表,拼接每一个Node对象的value值
    		for (int i = 0; i < size-1; i++) {//因为上面已经拼接了第一个元素,所以遍历了size-1次
    			sb.append(",");//拼接元素value前要先拼接,
    			temp = temp.next;//将下一个元素的地址赋值给临时变量temp保存
    			sb.append(temp.value);//拼接下一个元素的value值
    		}
    		//循环完毕后,所有元素的value值就拼接好了
    		return sb.append("]").toString();
    	}
    	
    	/**
    	 * 根据下标查询当前的节点对象 Node searchNodeByIndex(int index)
    	 * @param index
    	 * @return
    	 */
    	private Node searchNodeByIndex(int index) {
    		//判断下标的合法性
    		checkIndex(index);
    		
    		//声明一个临时变量保存遍历到的Node元素
    		Node temp = first;
    		
    		//遍历链表,循环次数index次
    		for (int i = 0; i < index; i++) {
    			//将下一个要遍历元素的地址赋值给临时变量temp
    			temp = temp.next;
    		}
    		//循环完毕后,肯定是要查找的Node对象
    		return temp;
    	}
    	
    	/**
    	 * 校验链表下标方法
    	 * @param index
    	 */
    	private void checkIndex(int index) {
    		if (index < 0 || index > size-1){
    			throw new IllegalArgumentException("亲,请注意下标范围是:[0," + (size-1) + "]");
    		}
    	}
    	
    	/**
    	 * 4. 查询指定下标的元素  Object searchByIndex(int index)
    	 * @param index
    	 * @return
    	 */
    	public Object searchByIndex(int index) {
    		//直接调用方法:根据下标查询当前的节点对象 Node searchNodeByIndex(int index)
    		Node node = searchNodeByIndex(index);
    		//直接返回该node的value值
    		return node.value;
    	}
    	
    	/**
    	 * 5. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
    	 * @param ele
    	 * @return
    	 */
    	public int searchByElement(Object ele) {
    		//声明一个临时变量保存遍历到的Node元素
    		Node temp = first;
    		
    		//在遍历之前就要判断ele是否为null,避免空指针异常
    		if (ele == null) {
    			//遍历链表,循环次数最多是size次
    			for (int i = 0; i < size; i++) {
    				if (ele == temp.value) {
    					return i;
    				}
    				//如果不相等,将下一个要遍历的地址赋值给temp
    				temp = temp.next;
    			}
    		}else {//只要在else中,已经排除了ele是null的情况
    			//遍历链表,循环次数最多是size次
    			for (int i = 0; i < size; i++) {
    				if (ele.equals(temp.value)) {
    					return i;
    				}
    				//如果不相等,将下一个要遍历的地址赋值给temp
    				temp = temp.next;
    			}
    		}
    		//遍历玩数组后,如果没有找到返回-1
    		return -1;
    	}
    	
    	/**
    	 * 6. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
    	 * @param index
    	 * @param obj
    	 * @throws IllegalArgumentException 
    	 */
    	public void updateByIndex(int index,Object obj) throws IllegalArgumentException{
    		//校验数组下标范围
    		checkIndex(index);
    		//调用查询指定下标的Node节点 Node searchNodeByIndex(int index)
    		Node node = searchNodeByIndex(index);
    		//直接将查询到的节点对象value值赋值为obj
    		node.value = obj;
    	}
    	
    	/**
    	 * 7. 删除指定下标处的元素,返回删除的元素  	Object deleteByIndex(int index)
    	 * @param index
    	 * @return
    	 * @throws IllegalArgumentException
    	 */
    	public Object deleteByIndex(int index) throws IllegalArgumentException{
    		//校验数组下标范围
    		checkIndex(index);
    		//如果是删除第一个元素,直接将第2个元素的地址赋值给first即可
    		Node now = null;
    		if (index == 0) {
    			//保存第一个元素
    			now = first;
    			//将第二个元素地址赋值给first
    			first = first.next;
    		} else {
    			//查询出index上一个节点
    			Node prefix = searchNodeByIndex(index-1);
    			//查询出要删除的index处的节点
    			now = searchNodeByIndex(index);
    			//将上一个节点的next赋值为index的next(就是index后一个的地址)
    			prefix.next = now.next;
    		} 
    		//元素个数-1
    		size--;
    		//将要删除的Node元素的value值返回
    		return now.value;
    	}
    	
    	/**
    	 * 8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
    	 * @param ele
    	 * @throws IllegalArgumentException 
    	 */
    	public void deleteByElement(Object ele) throws IllegalArgumentException{
    		//调用方法查找该元素下标,如果下标是-1,表示该链表中没有该元素,直接结束方法
    		int index = searchByElement(ele);
    		if (index < 0) {
    			return;
    		}
    		//调用上面根据指定下标删除元素方法
    		deleteByIndex(index);
    	}
    	
    	/**
    	 * 9. 插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
    	 * 跟删除方法类似,通过画图得知,只需要将index上一个元素的next赋值为当前插入的元素地址,将插入的元素next赋值为index处元素的地址即可
    	 * @param index
    	 * @param obj
    	 * @throws IllegalArgumentException 
    	 */
    	public void insertByIndex(int index,Object obj) throws IllegalArgumentException{
    		//校验数组下标范围
    		checkIndex(index);
    		//创建一个Node对象,保存obj的值
    		Node node = new Node(obj);
    		//如果是插入的下标是0,直接将第first元素的地址赋值给新插入的元素next,将first赋值为新插入的元素地址即可
    		if (index == 0) {
    			//将原来的第一个元素地址赋值给新插入的元素next保存
    			node.next = first;
    			//将first赋值为新插入的元素node地址即可
    			first = node;
    		} else {
    			//查询出index上一个节点
    			Node prefix = searchNodeByIndex(index-1);
    			//查询出插入index处的节点
    			Node now = searchNodeByIndex(index);
    			//将新插入的节点node的next赋值为index处的now的地址
    			node.next = now;
    			//将是一个节点的next赋值为新插入的node地址
    			prefix.next = node;
    		} 
    		//元素个数+1
    		size++;
    	}
    	
    	/**
    	 * 10.将对象中所有元素清空 void clear();
    	 */
    	public void clear(){
    		//直接将第一个元素赋值null即可
    		first = null;
    		//元素个数归零
    		size = 0;
    		//思路扩展:更好的方式是将链表遍历后,将每一元素赋值为null,有利于GC回收垃圾,提高资源利用率
    	}
    	
    	/**
    	 * 11.创建对象,可以直接传入一个参数初始化
    	 * @param obj
    	 */
    	public SinglyLinkedList(Object obj){
    		//因为是第一次添加,所以直接调用添加方法即可
    		add(obj);
    	}
    	
    	/**
    	 * 内部类
    	 * 不希望在SinglyLinkedList外部被使用到当前Node类,所以用private修饰
    	 */
    	private class Node{
    		/**保存添加的数据*/
    		Object value;
    		
    		/**保存的是下一个Node对象的地址(元素地址)*/
    		Node next;
    		
    		/**
    		 * 每次添加元素的时候,就要创建一个Node对象,并且给该
    		 * 对象的value赋值,赋值为新建的元素值
    		 * @param value
    		 */
    		public Node(Object value) {
    			this.value = value;
    		}
    	}
    }
    
    
    展开全文
  • SharedPreferences保存对象和list数据

    千次阅读 2018-07-31 13:58:22
    使用google的gson,可以对象转换成json字符串,这样就可以使用SharedPreferences保存数据。 使用时,请先下载gson的jar包。 代码如下: package com.example.app; import android.content.Context; import ...

    使用google的gson,可以把对象转换成json字符串,这样就可以使用SharedPreferences保存数据。

    使用时,请先下载gson的jar包。

    代码如下:

    package com.example.app;
    
    import android.content.Context;
    import android.content.SharedPreferences;
    import android.util.Log;
    
    import com.google.gson.Gson;
    import com.google.gson.JsonArray;
    import com.google.gson.JsonElement;
    import com.google.gson.JsonParser;
    import com.google.gson.reflect.TypeToken;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class DataSave {
        private final String TAG = "DataSave";
        private SharedPreferences preferences;
        private SharedPreferences.Editor editor;
    
        public DataSave(Context mContext, String preferenceName) {
            preferences = mContext.getSharedPreferences(preferenceName, Context.MODE_PRIVATE);
            editor = preferences.edit();  
        }
    
        /** 
         * save json string of data list to share preference
         * @param tag 
         * @param datalist 
         */  
        public <T> void setDataList(String tag, List<T> datalist) {
            if (null == datalist)
                return;
      
            Gson gson = new Gson();
            //change datalist to json
            String strJson = gson.toJson(datalist);
            Log.d(TAG,"setDataList, json:"+strJson);
            editor.clear();
            editor.putString(tag, strJson);
            editor.commit();
        }
      
        /**
         * get data List from share preferences
         * @param tag share preferences data tag
         * @param cls target list element object class
         * @return list
         */  
        public <T> List<T> getDataList(String tag, Class<T> cls) {
            List<T> datalist=new ArrayList<T>();
            String strJson = preferences.getString(tag, null);
            if (null == strJson) {
                return datalist;
            }
            Log.d(TAG,"getDataList, json:"+strJson);
            try {
                Gson gson = new Gson();
                JsonArray array = new JsonParser().parse(strJson).getAsJsonArray();
                for (JsonElement jsonElement : array) {
                    datalist.add(gson.fromJson(jsonElement, cls));
                }
            } catch (Exception e) {
                Log.e(TAG,"Exception : "+e.getMessage());
            }
            return datalist;
        }
    
        /**
         * save json string of data to share preference
         * @param tag
         * @param data object
         */
        public <T> void setData(String tag, T data) {
            if (null == data)
                return;
    
            Gson gson = new Gson();
            //change data to json
            String strJson = gson.toJson(data);
            Log.d(TAG,"setData, json:"+strJson);
            editor.clear();
            editor.putString(tag, strJson);
            editor.commit();
        }
    
        /**
         * get data from share preferences
         * @param tag share preferences data tag
         * @param cls target object class
         * @return target object or null if error happyed
         */
        public <T> T getData(String tag, Class<T> cls) {
            T data = null;
            String strJson = preferences.getString(tag, null);
            if (null == strJson) {
                return null;
            }
            Log.d(TAG,"getData, json:"+strJson);
            try {
                Gson gson = new Gson();
                JsonElement jsonElement = new JsonParser().parse(strJson);
                 data = gson.fromJson(jsonElement, cls);
            } catch (Exception e) {
                Log.e(TAG,"Exception : "+e.getMessage());
            }
            return data;
        }
    }  

    使用示例:

    private void saveConfig(Config config) {
        DataSave data = new DataSave(this, "ConfigData");
        data.setData("config",config);
    }
    
    private Config loadConfig() {
        DataSave data = new DataSave(this, "ConfigData");
        return data.getData("config", Config.class);
    }

     

    展开全文
  • #声明一个类型 class People(object): #类变量 file_name = 'student.txt' def __init__(self,name,school): self.name = name self.school = school #属性可以是列表 self.pdc = []
    #声明一个类型
    class People(object):
        #类变量
        file_name = 'student.txt'
        def __init__(self,name,school):
            self.name = name
            self.school = school
            #属性可以是列表
            self.pdc = []
            #属性也可以是字典
            self.pdc_dict = {}
        #保存数据的函数
        def save_data(self):
            #1.打开文件
            f = open(self.file_name,'a',encoding='utf-8')
            #2.写入数据
            f.write(self.name)
            f.write(';')
            f.write(self.school)
            f.write('\n---->')
            #将所有的前任名称拼接成一个字符串
            pdc_str = ' '.join(self.pdc)
            f.write(pdc_str)
            f.write('\n')
            #3.关闭文件
            f.close()
    People.file_name = 'stu.txt'
    #创建一个People对象
    #对象有保存信息到本地的函数
    p1 = People('张三','智游')
    # p1.save_data()
    p2 = People('李四','智游')
    # p1.save_data()
    # 获取对象的属性值,这个属性值是一个列表
    p1.pdc.append(p2.name)
    print(p1.pdc)
    
    p3 = People('豆豆','智游')
    # p1.pdc是一个列表,列表的增删改查都可以正常操作
    p1.pdc.append(p3.name)
    print(p1.pdc)
    # 遍历p1的所有前任名称
    for name in p1.pdc:
        print(name)
    p1.save_data()
    

    展开全文
  • iOS编程经常有要存数据的需求,例如这次做的购物app,希望把用户放在购物车里的数据存起来,以便用户下次运行程序时还可以看到购物车保存的商品,保存数据的几种方式可以参考另一个博主的文章:  ...
  • import java.util.Arrays; /** * 基于数组,适用于... * 底层是基于数组,因为是可以装不同数据类型的数据,所以是Object数组 * int/byte/short /boolean.... * Object[] value = new Object[10];
  • 程序在运行过程中,可能需要将一些数据永久的保存到磁盘上,而数据在Java中都是保存对象当中的。那么我们要怎样将对象中的数据保存到磁盘上呢?这时就需要使用Java中的对象序列化。 定义: 对象的序列化...
  • 作为数据源,DataSet可以提供多个数据表,在DataSet中可以进行表的关联操作工作,同样,每个DataTable对象可以作为数据源。下面这个实例演示了DataTable对象如何提供给DropDownList控件提供数据源的。 新建一个Web...
  • 1 cookie是以键值对保存在浏览器端,服务器端可以创建、接收、...正数,浏览器会将数据保存到硬盘中,如果没有超过过期时间,就可以一直访问。时间单位是秒。 负数,浏览器会将数据保存在内存中,关闭浏览器数据...
  • 1.序列化 ...把字节序列化保存到文件中,就可以做到持久化保存数据内容。 1.2 如何将对象数据序列化保存到文件 使用ObjectOutputStream完成序列化操作: Constructor:  ObjectOutputStream(OutputS...
  • pageContext对象是JSP技术中最重要的一个对象,它代表JSP页面的运行环境,这个对象不仅封装了对其它8大隐式对象的引用,它自身还是一个域对象可以用来保存数据。并且,这个对象还封装了web开发中经常涉及到的一些...
  • session看了一下,是可以保存对象的。语法很普通,但是cookie的话本身是只能保存string类型的信息的,这就需要先序列化,然后接收的页面反序列化后形成对象调用,为了防止乱码,需要在数据传输的时候加入编码格式,...
  • Android下通过文件或者通过sharedPreference都可以保存对象 IOS下使用NSCoder保存起来,也很方便。 Android:文件保存对象 (要保存的对象一定要实现序列化的接口 implements Serializable) (1)创建一个输出...
  • 保存数据返回后可以继续编辑

    千次阅读 2014-01-09 09:48:36
    一般来说, 调用onPause()和onStop()方法后的activity实例仍然存在于内存中, activity的所有信息和状态数据不会消失, 当activity重新回到前台之后, 所有的改变都会得到保留.  但是当系统内存不足时, 调用onPause()...
  • 有六个地方都可以保存数据:   (1) 寄存器。这是最快的保存区域,因为它位于和其他所有保存方式不同的地方:处理器内部。然而,寄存器的数量十分有限,所以寄存器是根 据需要由编译器分配。我们对此没有...
  • 而且数据的字段很多的时候不肯能在后台NEW一个对象,再set,所以封装成一个完整对象提交到后台,直接保存对象,这样代码看起来也比较清爽,这个在S2SH里是很简单的能实现的,最开始用S2SH提交,能完整提交,但是...
  • Android 使用SharedPreferences保存各种数据(List,Map,对象等)SpUtils简介存储List数据到本地的方式有很多种,对于不想用sqlite或者其他方式,又或是数据量很少的话,不妨可以试下用 SharedPreferences保存。...
  • var 指定将当前迭代到的元素保存到page这个Web域中的属性名称 默认保存在pageContext域中 有的标签可以通过scope属性设置域对象范围
  • 可以将图片或者swf文件转化成byteArray缓存到本地,见下面的源码:package {  import flash.display.Bitmap;  import flash.display.BitmapData;  import flash.display.PixelSnapping;  import flash....
  • 数据保存

    2017-03-16 16:35:51
    保存到Preference SharedPreference是Android提供的一种轻量级的数据存储方式,主要用来存储一些简单的配置信息,例如,默认欢迎语,登录用户名和密码等。... SharedPreferences 对象指向一个保存key-
  • 主键id是自动增长: &lt;insert id="insert" parameterType="com.demo.Student"&gt; &lt;selectKey resultType="java.lang.Long"... SELECT LAST_INSERT_
  • python pickle&dill保存数据

    千次阅读 2020-02-02 21:40:05
    其中pickle 不可以保存lambda函数,序列化对象等,但dill可以保存。其中pickle 和 dill 的用法一样,使用时,采用 import pickle  或 import dill as pickle 基本用法 保存数据 with open('dataset.pkl', '...
  • 可以将 JavaScript 对象中表示的一组数据转换为字符串,然后就可以在网络或者程序之间轻松地传递这个字符串,并在需要的时候将它还原为各编程语言所支持的数据格式,例如在 PHP 中,可以将 JSON 还原为数组或者一个...
  • 使用SharedPreferences保存对象我们知道,SP可以保存像String和int这样的简单类型的数据,但不能直接保存对象。在需要保存对象的时候,就需要用到格式转换。步骤:1、将复杂数据(obj)转换为字节码;...
  • dto对象是对原始对象的扩展,用于数据保存和传递。 前面提到,在保存和传输多表关联查询结果时,可以修改普通实体类进行扩展。平时开发的时候,很多程序员都是这么干的,包括我在内。但严格来讲,这是代码不规范的...
  • 这里简单的封装一下iOSAPP数据本地存储工具类,为...可以跨类全局存取。 如我这里要存取用户信息(是不是使用很简单): //存自定义对象 JYUserModel * dataModel = [[JYUserModel alloc]init]; dataModel.userN...
  • @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public String rankScoreIn... if (classname == null) { 这两个条件都满足时,只保存最后一条,其他条件则可以保存正常 请问是什么原因?
  • 对于相关对象的处理首先是写一个存储结构存储,对存储结构进行构造构造完后写getset方法构造器等内容,然后对构造器用集合List或其他存储结构进行存储后再进行添加 package edu.vision.Test; import org.opencv....
  • Request作为域对象存取数据 Request作为域对象 ...向Request域中保存数据:setAttribute(String name, Object o);   从Request域中获取数据:getAttribute(String name);   从Request域中移除数据:remov
  • 9. 数据保存

    千次阅读 2016-04-10 11:40:24
    pickle和marshal模块可以把多种Python数据类型的数据生成一个字节流,然后从字节流创建一个对象。不同类型的DB管理模块支持HASH的映射字符串保存。9.1 pickle--Python对象序列化操作本模块主要提供了二进制协议来对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,303
精华内容 7,321
关键字:

对象可以保存数据