Android通过httpClient获取网络请求,响应状态码含义,Http请求时要添加权限

Android通过httpClient获取网络请求

在HttpClient模块中用到了两个重要的类:HttpGet和HttpPost。这两个类分别用来提交HTTP GET和HTTP POST请求。

无论是使用HttpGet,还是使用HttpPost,都必须通过如下3步来访问HTTP资源。

  • 1.创建HttpGet或HttpPost对象,将要请求的URL通过构造方法传入HttpGet或HttpPost对象。
  • 2.使用DefaultHttpClient类的execute方法发送HTTP GET或HTTP POST请求,并返回HttpResponse对象。
  • 3.通过HttpResponse接口的getEntity方法返回响应信息,并进行相应的处理。(判断请求响应状态码,状态码为200表示服务端成功响应了客户端的请求。

响应状态码含义

  • ◆200 (OK): 找到了该资源,并且一切正常。
  • ◆304 (NOT MODIFIED): 该资源在上次请求之后没有任何修改。这通常用于浏览器的缓存机制。
  • ◆401 (UNAUTHORIZED): 客户端无权访问该资源。这通常会使得浏览器要求用户输入用户名和密码,以登录到服务器。
  • ◆403 (FORBIDDEN): 客户端未能获得授权。这通常是在401之后输入了不正确的用户名或密码。
  • ◆404 (NOT FOUND): 在指定的位置不存在所申请的资源。
    )。

Http请求时要添加权限!!!

找了一下午真是活该!
没加权限竟然。

07-18 09:05:31.824    1781-1794/com.zsz.develop.myrobot E/AndroidRuntime﹕ FATAL EXCEPTION: AsyncTask #1
java.lang.RuntimeException: An error occured while executing doInBackground()

错误行数在

httpResponse= httpClient.execute(httpGet);

public class HttpData extends AsyncTask<String, Void, String> {

下回涨点记性

获取上下文路径,get和post

问题集

request.getContextPath()获取上下文路径

超级实用的小技巧

《form action=”<%=request.getContextPath() %>/loginServlet” method=”post”>

Servlet添加到web。xml中的信息

其中url中的值要与上面相对应。

LoginServlet
com.zsz.develop.servlet.LoginServlet

<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/loginServlet</url-pattern>
</servlet-mapping>

get和post

JDBC API,JDBC Driver API,JDBC的操作流程,事务的四个特征,JDBC事务处理

7.13日问题集

JDBC API

DriverManager:这是一个驱动程序管理类,用来装载驱动程序。并为创建数据库连接提供支持

  • Connection:connection是一个接口,用来连接某一特定的数据库。

  • Statement:statement接口提供了执行SQL语句。获取查询结果的方法

  • PreparedStatement:是statement的子接口,用来执行编译的sql语句

  • ResultSet:该接口提供了对结果集的处理方法

JDBC Driver API

JDBC Driver API是面向驱动程序开发商的接口

主要有四种:

  • JDBC-ODBC bridge:这种驱动程序会把jdbc的调用委托给其他接口
  • 部分java技术的本地api驱动程序
  • 全部基于java技术的本地api驱动程序
  • 全部基于java技术的本地协议驱动程序

JDBC的操作流程

Class.forName()

Class:这个类封装了要装载到JVM中类的信息。比如类的成员方法,成员变量,以及这个类实现的接口。

forName():这个方法用来初始化指定参数的类。并创建一个对应的实例对象

参数中的字符串:是mysql指定的字符串驱动程序

事务的四个特征

事务是作为一个逻辑单元执行的一系列操作,一个逻辑工作单元必须有四个属性,称为 ACID(原子性、一致性、隔离性和持久性)属性,只有这样才能成为一个事务:

  • 原子性
    事务必须是原子工作单元;对于其数据修改,要么全都执行,要么全都不执行。

  • 一致性
    事务在完成时,必须使所有的数据都保持一致状态。在相关数据库中,所有规则都必须应用于事务的修改,以保持所有数据的完整性。事务结束时,所有的内部数据结构(如 B 树索引或双向链表)都必须是正确的。

  • 隔离性
    由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态,要么是另一并发事务修改它之前的状态,要么是另一事务修改它之后的状态,事务不会查看中间状态的数据。这称为可串行性,因为它能够重新装载起始数据,并且重播一系列事务,以使数据结束时的状态与原始事务执行的状态相同。

  • 持久性
    事务完成之后,它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。

JDBC事务处理

http://blog.csdn.net/csc0211/article/details/6232047

在JDBC的数据库操作中,一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。我们通过提交commit()或是回退rollback()来结束事务的操作。关于事务操作的方法都位于接口java.sql.Connection中。

首先我们要注意,在JDBC中,事务操作默认是自动提交。也就是说,一条对数据库的更新表达式代表一项事务操作。操作成功后,系统将自动调用commit()来提交,否则将调用rollback()来回退。
其次,在JDBC中,可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务,在操作完成后调用commit()来进行整体提交。倘若其中一个表达式操作失败,都不会执行到commit(),并且将产生响应的异常。此时就可以在异常捕获时调用rollback()进行回退。这样做可以保持多次更新操作后,相关数据的一致性。
具体事例如下:

        try {
    Class.forName("oracle.jdbc.driver.OracleDriver");
    conn = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:luecc", "scott", "tiger");
                //点禁止自动提交,设置回退
    conn.setAutoCommit(false);
    stmt = conn.createStatement();
                //数据更新
    stmt.addBatch("insert into dept values (51, '500', 'ccc')");
    stmt.addBatch("insert into dept values (52, '600', 'ddd')");
    stmt.addBatch("insert into dept values (53, '700', 'eee')");
    stmt.executeBatch();
                //事务提交 
    conn.commit();
    conn.setAutoCommit(true);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
} catch(SQLException e) {
    e.printStackTrace();
    try {
        if(conn != null)
        {
                                //操作不成功则回退
            conn.rollback();
                                //重新设置恢复默认值
            conn.setAutoCommit(true);
        }
    } catch (SQLException e1) {
        e1.printStackTrace();
    }
}

For-Each循环,两种方式实现插入,增删改查,完整的JDBC代码

7.12问题集

For-Each循环

Java[編輯]
Java語言從JDK 1.5.0開始引入foreach循環。

以下代碼用於循環列印myArray數組中的每個元素,java中的foreach循環使用for關鍵字,而非foreach。

for (int x : myArray){
  System.out.println(x);
}

他的语法如下

for(type element: array)

  {

   System.out.println(element);

  }

两种方式实现插入

第一种直接书写sql语句。

public void insert(UserInfo userInfo){
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    try {

        String sqlinsert="insert into userinfo(name,password)"+ "values('"+userInfo.getName()+"','"+userInfo.getPassword()+"')";
        System.out.println(sqlinsert);
        ps=(PreparedStatement) conn.prepareStatement(sqlinsert);

        //注意:这里不要传入参数(),executeUpdate()增删改都使用者种方法。
        int i=ps.executeUpdate();
        if (i>0) {
            System.out.println("添加成功");
        }else {
            System.out.println("添加失败");
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        //rs.ps.conn都是跟数据库连接相关的。当我们使用完毕,必须关闭资源,防止堵死。顺序的后打开先关闭
        try {

            if (ps!=null) {
                ps.close();
            }
            if (conn!=null) {
                conn.close();
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }
    }
}

第二种使用占位符书写

/*
 *占位符的优势。
 *1.效率更高
 *2.书写时不容易出错
 *3.防止sql注入(安全问题) 
 */


public void insert2(UserInfo userInfo){
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    try {

        String sqlinsert="insert into userinfo(name,password)"+ "values(?,?)";
        System.out.println(sqlinsert);
        ps=(PreparedStatement) conn.prepareStatement(sqlinsert);
        ps.setString(1, userInfo.getName());
        ps.setString(2, userInfo.getPassword());
        //注意:这里不要传入参数(),executeUpdate()增删改都使用者种方法。
        int i=ps.executeUpdate();
        if (i>0) {
            System.out.println("添加成功");
        }else {
            System.out.println("添加失败");
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        //rs.ps.conn都是跟数据库连接相关的。当我们使用完毕,必须关闭资源,防止堵死。顺序的后打开先关闭
        try {

            if (ps!=null) {
                ps.close();
            }
            if (conn!=null) {
                conn.close();
            }
            } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

    }
}
}

他的调用我也补充一下

public static void main(String[] args) {
        ArrayList<UserInfo> arrayList= new UserInfoDao().getList();
        UserInfo userInfo=new UserInfo();
        userInfo.setName("shan");
        userInfo.setPassword("123---");
        new UserInfoDao().insert(userInfo);

    }

}

更新操作

public void update(UserInfo userInfo){
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    String updateSQL="update userinfo set name=?,password=?"+"where id=?";

    try {
        ps=(PreparedStatement) conn.prepareStatement(updateSQL);
        ps.setString(1, userInfo.getName());
        ps.setString(2, userInfo.getPassword());
        ps.setInt(3, userInfo.getId());
        System.out.println(updateSQL);

        int a=ps.executeUpdate();
        if (a>0) {
            System.out.println("更改完成");
        }
        if (a<0) {
            System.out.println("更改失败");

        }
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
            try {
                if (ps!=null) {
                    ps.close();
                }
                if (conn!=null) {
                    conn.close();
                }
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

    }

}

注意点:ps.setString(1, userInfo.getName());这是从1开始添加。

删除数据

public void delete(int id) {
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    String deleteSQL="delete from userinfo where id=?";

    try {
        ps=(PreparedStatement) conn.prepareStatement(deleteSQL);
        ps.setInt(1, id);
        int a=ps.executeUpdate();
        if (a>0) {
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        try {
            if (ps!=null) {
                ps.close();
            }
            if (conn!=null) {
                conn.close();
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
    }
}

进行代码优化——1,关闭资源

注意:参数有两个或者三个的。这时候就要使用参数多态性

当使用的时候就直接调用者两个函数就可以了
public static void closeResource(PreparedStatement ps,Connection conn){

    try {
        if (ps!=null) {
            ps.close();
        }
        if (conn!=null) {
            conn.close();
        }
        } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
}

public static void closeResource(ResultSet rs,PreparedStatement ps,Connection conn){

    try {
        if (rs!=null) {
        rs.close();

        }
        if (ps!=null) {
            ps.close();
        }
        if (conn!=null) {
            conn.close();
        }
        } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
}

代码优化之二———使用boolean值作为返回值来判断是否修改成功

前面的修改例子中,修改成功是显示在控制台上。而这种方法修改成功是显示在返回值

public boolean delete(int id) {
    boolean b=false;
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    String deleteSQL="delete from userinfo where id=?";

    try {
        ps=(PreparedStatement) conn.prepareStatement(deleteSQL);
        ps.setInt(1, id);
        int a=ps.executeUpdate();
        if (a>0) {
            b=true;
        }else {
            System.out.println("删除失败");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        BaseConnection.closeResource(ps, conn);
    }
    return b;
}

完整的JDBC代码

package com.zsz.develop.dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;

import org.omg.CORBA.portable.ValueBase;
import org.omg.PortableServer.ID_ASSIGNMENT_POLICY_ID;

import com.mysql.jdbc.PreparedStatement;
import com.zsz.develop.bean.UserInfo;
import com.zsz.develop.util.BaseConnection;

public class UserInfoDao {

public ArrayList<UserInfo> getList(){
    ArrayList<UserInfo> arrayList=new ArrayList<UserInfo>();
    Connection conn=BaseConnection.getConnection();
    //定义在外面是要让他成为全局变量
    PreparedStatement ps=null;
    ResultSet rs=null;
    String sql="select * from userinfo";

    try {
        ps=(PreparedStatement) conn.prepareStatement(sql);
         rs =ps.executeQuery();
        while (rs.next()) {
//                System.out.println(rs.getString("name")+"-----");
            //把数据封装到实体类
            UserInfo userInfo=new UserInfo();
            userInfo.setId(rs.getInt("id"));
            userInfo.setName(rs.getString("name"));
            userInfo.setPassword(rs.getString("password"));
            //再把封装好的对象放到我们的集合中去
            arrayList.add(userInfo);
        }




    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        //rs.ps.conn都是跟数据库连接相关的。当我们使用完毕,必须关闭资源,防止堵死。顺序的后打开先关闭
            BaseConnection.closeResource(rs, ps, conn);
    }

    return arrayList;
}

public boolean insert(UserInfo userInfo){
    boolean b=false;
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    try {

        String sqlinsert="insert into userinfo(name,password)"+ "values('"+userInfo.getName()+"','"+userInfo.getPassword()+"')";
        System.out.println(sqlinsert);
        ps=(PreparedStatement) conn.prepareStatement(sqlinsert);

        //注意:这里不要传入参数(),executeUpdate()增删改都使用者种方法。
        int i=ps.executeUpdate();
        if (i>0) {
            b=true;
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        BaseConnection.closeResource( ps, conn);
    }
    return b;
}
/*
 *占位符的优势。
 *1.效率更高
 *2.书写时不容易出错
 *3.防止sql注入(安全问题) 
 */


public boolean insert2(UserInfo userInfo){
    boolean b=false;
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    try {

        String sqlinsert="insert into userinfo(name,password)"+ "values(?,?)";
        System.out.println(sqlinsert);
        ps=(PreparedStatement) conn.prepareStatement(sqlinsert);
        ps.setString(1, userInfo.getName());
        ps.setString(2, userInfo.getPassword());
        //注意:这里不要传入参数(),executeUpdate()增删改都使用者种方法。
        int i=ps.executeUpdate();
        if (i>0) {
            b=true;
        }else {
            System.out.println("添加失败");
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        //rs.ps.conn都是跟数据库连接相关的。当我们使用完毕,必须关闭资源,防止堵死。顺序的后打开先关闭
        BaseConnection.closeResource(ps, conn);

    }
    return b;
}


public boolean update(UserInfo userInfo){
    boolean b=false;
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    String updateSQL="update userinfo set name=?,password=?"+"where id=?";

    try {
        ps=(PreparedStatement) conn.prepareStatement(updateSQL);
        ps.setString(1, userInfo.getName());
        ps.setString(2, userInfo.getPassword());
        ps.setInt(3, userInfo.getId());
        System.out.println(updateSQL);

        int a=ps.executeUpdate();
        if (a>0) {
            b=true;
        }



    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
            BaseConnection.closeResource(ps, conn);

    }
    return b;
}

public boolean delete(int id) {
    boolean b=false;
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;
    String deleteSQL="delete from userinfo where id=?";

    try {
        ps=(PreparedStatement) conn.prepareStatement(deleteSQL);
        ps.setInt(1, id);
        int a=ps.executeUpdate();
        if (a>0) {
            b=true;
        }else {
            System.out.println("删除失败");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally{
        BaseConnection.closeResource(ps, conn);
    }
    return b;
}



}

连接数据库代码,为什么静态类方法可以直接调用?,.PreparedStatement和Statement的使用,结果集(ResultSet)用法

711问题集

  • 1.The local variable conn may not have been initialized

    局部变量没有初始化问题?

局部变量在进行读取操作之前必须进行初始化或进行赋值操作,否则会出现编译错误.

- 2.连接数据库代码

package com.zsz.develop.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class BaseConnection {

public static Connection getConnection(){    

    Connection conn=null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "SF948640.");
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return conn;
}

}

- 3.为什么静态类方法可以直接调用?

这是因为静态类方法实际上属于类,不同任何类实例相关,也不允许访问任何实例属性;因此这些方法可以共享,可以直接调用;而普通方法需要同类实例相关,因此必须在对应的实例中访问。

    public static void main(String[] args) {
//当connection成为静态时、就可以直接调用。
//        Connection conn=new BaseConnection().getConnection();
    Connection conn=BaseConnection.getConnection();
    System.out.println(conn);
}

- 4.PreparedStatement和Statement的使用

PreparedStatement和Statement都是SQL执行器对象。PreparedStatement 对象已预编译过(所以第一次执行花费更多时间),所以其执行速度要快于 Statement 对象。

JDBC驱动的最佳化是基于使用的是什么功能. 选择PreparedStatement还是Statement取决于你要怎么使用它们. 对于只执行一次的SQL语句选择Statement是最好的. 相反, 如果SQL语句被多次执行选用PreparedStatement是最好的.

- 5.结果集(ResultSet)用法

ResultSet,数据库结果集的数据表,通常通过执行查询数据库的语句生成。

ResultSet里面是一个指针数据,他首先指向0位置,也就是标题。当他使用next()时。他读取的才是真正的数据。然后通过0位置的标题对比逐个取出数据

简单实例

    public ArrayList<UserInfoDao> getList(){
    ArrayList<UserInfoDao> arrayList=new ArrayList<UserInfoDao>();
    Connection conn=BaseConnection.getConnection();
    //sql执行器Statement
    PreparedStatement ps=null;
    //ResultSet结果集对象
    String sql="select * from userinfo";
    try {
        ps=ps=(PreparedStatement) conn.prepareStatement(sql);
        rs =ps.executeQuery();
        while (rs.next()) {
            System.out.println(rs.getString("name")+"-----");
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return arrayList;
}

把他存进实体类,再读取出来的案例

package com.zsz.develop.dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;

import com.mysql.jdbc.PreparedStatement;
import com.zsz.develop.bean.UserInfo;
import com.zsz.develop.util.BaseConnection;

public class UserInfoDao {

public ArrayList<UserInfo> getList(){
    ArrayList<UserInfo> arrayList=new ArrayList<UserInfo>();
    Connection conn=BaseConnection.getConnection();
    PreparedStatement ps=null;

    String sql="select * from userinfo";
    try {
        ps=(PreparedStatement) conn.prepareStatement(sql);
        ResultSet rs =ps.executeQuery();
        while (rs.next()) {
//                System.out.println(rs.getString("name")+"-----");
            //把数据封装到实体类
            UserInfo userInfo=new UserInfo();
            userInfo.setId(rs.getInt("id"));
            userInfo.setName(rs.getString("name"));
            userInfo.setPassword(rs.getString("password"));
            //再把封装好的对象放到我们的集合中去
            arrayList.add(userInfo);
        }

    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return arrayList;
}
//添加再其他地方既可以使用。
//    public static void main(String[] args) {
//        ArrayList<UserInfo> arrayList= new UserInfoDao().getList();
//        //用新型for循环把他打印出来
//        for(UserInfo userInfo:arrayList){
//            System.out.println(userInfo.getId()+"  "+userInfo.getName()+"  "+userInfo.getPassword());
//        }
//    }

}

Android传数据到服务器端

Android传数据到服务器端

在之前的博客中提到主线程中不能操作耗时的操作,例如网络操作。

今天使用实例来使用AsnycTask。

 public Robot query(Robot rqRobot) {

    Gson gson=new Gson();
    String url= MyData.URL+"RobotServlet";
    HttpClient client=new DefaultHttpClient();
    HttpPost post=new HttpPost(url);
    List<NameValuePair> rqParmeter=new ArrayList<>();
    rqParmeter.add(new BasicNameValuePair("input",gson.toJson(rqRobot)));
    try {
        post.setEntity(new UrlEncodedFormEntity(rqParmeter, HTTP.UTF_8));

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }

    Robot rpRobot=null;
    Log.e("niinin","----------------------------");

    try {
        HttpResponse httpResponse=client.execute(post);
        int statusCode=  httpResponse.getStatusLine().getStatusCode();

        Log.e("dsdsd",statusCode+"");
        if (statusCode==200){
            HttpEntity httpEntity= httpResponse.getEntity();
            Log.e("niinin",httpResponse.getEntity().toString());
          rpRobot=gson.fromJson(EntityUtils.toString(httpEntity),Robot.class);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    return rpRobot;
}

执行client上传数据,接收到的就是返回值:
HttpResponse response = client.execute(post);

得到返回值:response.getEntity()

但是得到的返回值不是字符串,要先把他转为字符串:

使用EntityUtils的方法来转化为字符串

EntityUtils.toString(response.getEntity());

 // setting request parameters
    List<NameValuePair> requestParameters = new ArrayList<>();
    // send imageSize parameter to server for recognition
    requestParameters.add(new BasicNameValuePair("action", "findById"));
    requestParameters.add(new BasicNameValuePair("imageSize", "400"));
    requestParameters.add(new BasicNameValuePair("id", Integer
            .toString(spotId)));

    try {
//要将list转化为转化为Entity,可以调用UrlEncodedFormEntity方法转化
        post.setEntity(new UrlEncodedFormEntity(requestParameters,
                HTTP.UTF_8));

http://zszdevelop.github.io/2015/05/27/2015-5-27/

java集合的使用

Java集合

java集合接口(接口不能直接实例化、要实例化他的子类):

  • Collection 接口
  • List接口
  • Set接口
  • Iterator接口
  • Map接口

接口之间的关系图

接口之间关系

集合

  • 1.集合可以理解为一个动态的对象数组,不同的是集合的对象内容可以任意扩充
  • 2.集合的特点:
    性能高,容易扩展和修改

    List接口

    List继承自Collection
  • 1.List接口可以存放任意的数据,而且在List接口中内容是可以重复的
  • 2.List接口常用子类
    • Arraylist
    • Vector

Arraylist和Vector的实现差不多,他们之间的区别就是

  • Arraylist:采用异步处理方式,性能高,属于非线程安全。
  • Vector:采用同步处理方式,性能低,属于线程安全。

ArrayList的简单实例

import java.util.ArrayList;
import java.util.List;

public class ListTest {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    //List是一个接口,必须实例化其子类。
    List<String> list=new ArrayList<String>();
    //集合使用add添加
    list.add("添加字符串");
    list.add("A");
    list.add("B");
    list.add("C");

    for (int i = 0; i <list.size(); i++) {
        //集合使用get方法来获取元素内容。
        System.out.println(list.get(i));
    }
    //remove删除操作
    list.remove(0);
    System.out.println("删除后的操作");
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    System.out.println("判断集合是否为空"+list.isEmpty());
    //indexOf返回值是元素的位置。
    System.out.println("判断元素是否存在,例如C: "+list.indexOf("C"));
}

}

Set接口

  • 1.Set接口中不能加入重复元素,但是可以排序
  • 2.常用子类:HashSet 和TreeSet

HashSet:无順序性,查找速度快
(注意相同多个D,set只会读取一个)
TreeSet:有排序性(依字母),由紅黑樹所建

import java.util.TreeSet;

public class SetTest {

public static void main(String[] args) {
    // TODO Auto-generated method stub

//        Set<String> set=new HashSet<String>();
    Set<String> set=new TreeSet<String>();
    set.add("2");
    set.add("4");
    set.add("1");
    set.add("31");
    set.add("a");
    set.add("D");
    set.add("D");

    System.out.println(set);
}

}

Iterator接口

1.集合输出的标准操作:标准做法,使用Iterator接口
2.操作原理:Iterator是专门的迭代输出接口,迭代输出就是将元素一个个进行判断,判断其是否有内容,如果有内容则把内容取出。

Iterator的实例化比较特别:是通过集合来获得他的一个对象,来实例化。

hasNext():判断集合中元素是否遍历完毕,如果没有,就返回true
next() :返回下一个元素

package com.zsz.develop;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorTest {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    List<Integer> list=new ArrayList<Integer>();
    for (int i = 0; i < 10; i++) {
        list.add(i);

    }
    //使用Iterator标准输出格式来输出
    Iterator<Integer> iterator=list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

}

Map接口

1.保存形式:是以Key—value对的方式来保存
2.常用子类

  • HashMap:无序存放,KEY不允许重复、
  • Hashtable:无序存放,KEY不允许重复、

在list,set中添加数据都是使用add,而map是使用put添加数据。
通过map.get()可以得到Key中的Value。

要得到所以的键:Map.keySet() 返回类型是set<>;
要得到所以的值:Map.Value 返回类型是Collection<>;

map实例

package com.zsz.develop;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    //键值对的形式来存储数据
    Map<String, String> map=new HashMap<String, String>();
    map.put("key1", "first");
    map.put("key2", "first2");
    map.put("key3", "first3");
    map.put("key4", "first4");

    //得到所以的键
    Set<String> set=map.keySet();
    Iterator<String> iterator=set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }

    System.out.println("上面为全部键,下面为全部值");
    //得到所有的值
    Collection<String> collection=map.values();
    Iterator<String> i=collection.iterator();
    while (i.hasNext()) {
        System.out.println(i.next());

    }

    //判断是否存在键
    System.out.println("是否存在键: "+map.containsKey("key1"));
    //判断是否存在值
    System.out.println("是否存在值: "+map.containsKey("first1"));

}


}

SharedPrefenences的使用

SharedPrefenences是什么

SharedPrefenences是一种轻型的数据存储方式,他的本质是基于XML文件存储Ket-Value键值对数据,通常用来存储一些简单的配置信息

存储位置在/data/data/<包名>/shared_prefs目录下。

SharedPrefenences对象本身只能获取数据而不支持存储和修改,存储修改要通过Editor对象实现。

SharedPrefenences的优势

SharedPrefenences与SQLite数据库相比,免去了创建数据库,创建表,写SQL语句等操作,更加易用。

支持的类型数据

  • boolean
  • int
  • float
  • long
  • String

但是无法进行条件查询。

SharedPrefenences的代码实现

Activity:

package com.zsz.develop.sharedpreferencestest;

import android.content.SharedPreferences;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;


public class MainActivity extends ActionBarActivity {

private EditText etData;
private  SharedPreferences sharedPreferences;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    etData= (EditText) findViewById(R.id.etData);
    sharedPreferences=getSharedPreferences("sharedPrefXML",MODE_PRIVATE);
    //要编辑修改sharedPreferences就要使用Editor来修改
   final SharedPreferences.Editor editor= sharedPreferences.edit();

    //读取SharedPreferences数据
    findViewById(R.id.btnRead).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            //得到sharedPreferences的值,传进去第一个参数是键,第二个是如果为空返回的值。
          String value=  sharedPreferences.getString("key-name","当前数值不存在");
            Toast.makeText(getApplicationContext(),value,Toast.LENGTH_SHORT).show();
        }
    });

    //写入SharedPreferences数据
    findViewById(R.id.btnWrite).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            //要修改存储什么类型数据就put什么类型,这里传进去的是Key-Value
            editor.putString("key-name",etData.getText().toString().trim());
            //commit提交数据,commit返回值为boolean。进行判断
          if (editor.commit()) {
              Toast.makeText(getApplicationContext(), "写入成功", Toast.LENGTH_SHORT).show();
          }
        }
    });



}



}

layout档:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<EditText
   android:layout_width="fill_parent"
   android:layout_height="wrap_content"
   android:id="@+id/etData"
   />
<Button
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:id="@+id/btnRead"
    android:text="读取数据"
    />

<Button
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:id="@+id/btnWrite"
    android:text="写入数据"
    />
</LinearLayout>

SharedPrefenences非常方便的使用。

清除用户数据

清除用户数据

非常实用的清空数据函数。

主要通过deleteFilesByDirectory()函数删除文件,来达到清楚数据的功能。

功能有清除内/外缓存,清除数据库,清除sharedPreference,清除files和清除自定义目录

package com.fsd.zsz.manplan.main;

/**
 * Created by shengzhong on 2015/6/3.
 */


import java.io.File;
import android.content.Context;
import android.os.Environment;
/** * 本应用数据清除管理器 */
public class DataCleanManager {
    /** * 清除本应用内部缓存(/data/data/com.xxx.xxx/cache) * * @param context */
    public static void cleanInternalCache(Context context) {
        deleteFilesByDirectory(context.getCacheDir());
    }
    /** * 清除本应用所有数据库(/data/data/com.xxx.xxx/databases) * * @param context */
    public static void cleanDatabases(Context context) {
        deleteFilesByDirectory(new File("/data/data/"
                + context.getPackageName() + "/databases"));
    }
    /**
     * * 清除本应用SharedPreference(/data/data/com.xxx.xxx/shared_prefs) * * @param
     * context
     */
    public static void cleanSharedPreference(Context context) {
        deleteFilesByDirectory(new File("/data/data/"
                + context.getPackageName() + "/shared_prefs"));
    }
    /** * 按名字清除本应用数据库 * * @param context * @param dbName */
    public static void cleanDatabaseByName(Context context, String dbName) {
        context.deleteDatabase(dbName);
    }
    /** * 清除/data/data/com.xxx.xxx/files下的内容 * * @param context */
    public static void cleanFiles(Context context) {
        deleteFilesByDirectory(context.getFilesDir());
    }
    /**
     * * 清除外部cache下的内容(/mnt/sdcard/android/data/com.xxx.xxx/cache) * * @param
     * context
     */
    public static void cleanExternalCache(Context context) {
        if (Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            deleteFilesByDirectory(context.getExternalCacheDir());
        }
    }
    /** * 清除自定义路径下的文件,使用需小心,请不要误删。而且只支持目录下的文件删除 * * @param filePath */
    public static void cleanCustomCache(String filePath) {
        deleteFilesByDirectory(new File(filePath));
    }
    /** * 清除本应用所有的数据 * * @param context * @param filepath */
    public static void cleanApplicationData(Context context, String... filepath) {
        cleanInternalCache(context);
        cleanExternalCache(context);
        cleanDatabases(context);
        cleanSharedPreference(context);
        cleanFiles(context);
        for (String filePath : filepath) {
            cleanCustomCache(filePath);
        }
    }
    /** * 删除方法 这里只会删除某个文件夹下的文件,如果传入的directory是个文件,将不做处理 * * @param directory */
    private static void deleteFilesByDirectory(File directory) {
        if (directory != null && directory.exists() && directory.isDirectory()) {
            for (File item : directory.listFiles()) {
                item.delete();
            }
        }
    }
}

出处:http://blog.csdn.net/berber78/article/details/38587567

Android设置日期与时间

Android设置日期与时间

取得设置系统时间是Android非常实用的一个功能

取得系统时间

实例化Calendar时,他已经默认的设置了系统时间。
setTimeInMillis()这个方法,会根据你传入的毫秒数对日历对象中的变量进行相应设置。System.currentTimeMillis()可以得到系统到距离1970年1月1日0时的毫秒数

      //Calendar定义日历对象
private Calendar calendar;
    //实例化日历对象
    calendar=Calendar.getInstance();
    //设置系统时间
    calendar.setTimeInMillis(System.currentTimeMillis());
    //得到系统时间
   final Date time=calendar.getTime();
    //得到时和分
   final int hour= calendar.get(Calendar.HOUR_OF_DAY);
    final int minute=calendar.get(Calendar.MINUTE);

时间选择器

时间选择器:
TimePickerDialog(Contextcontext,TimePickerDialog.OnTimeSetListenercallBack, int hourOfDay, int minute, boolean is24HourView)

  • 其中TimePickerDialog.OnTimeSetListenercallBack是用户选择好时间后,通知应用的回调函数。监听用户更改时间参数,调用的方法。

  • is24HourView选择是否为24小时制

tvTime= (TextView) findViewById(R.id.tvTime);
   tvTime.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View view) {
           new TimePickerDialog(MainActivity.this,new TimePickerDialog.OnTimeSetListener() {
               @Override
               public void onTimeSet(TimePicker timePicker, int i, int i2) {
                   tvTime.setText("shi"+i+"fen"+i2);
               }
           },10,20,true).show();
       }
   });

日期选择器

同理时间选择器

tvDate= (TextView) findViewById(R.id.tvDate);
   tvDate.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View view) {

           new DatePickerDialog(MainActivity.this, new DatePickerDialog.OnDateSetListener() {
               @Override
               public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {

                   tvDate.setText(String.format("%d:%d:%d",year,monthOfYear,dayOfMonth));
               }

           },2015,6,2).show();
       }
   });

Layout档

   <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="0000:00:00"
    android:id="@+id/tvDate"
    />

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="00:00:00"
    android:id="@+id/tvTime"
    />