精华内容
下载资源
问答
  • 不知道你们有没有对用户输入东西进行过敏感校验,如果不进行校验...问题如果我们数据是get请求倒还好,但是如果是一些数据量比较大,我们需要通过post json方式来说传递数据时候,这个时候其实是通过流的方...

    不知道你们有没有对用户输入的东西进行过敏感校验,如果不进行校验,用户属于一些攻击脚本,那么我们的服务就挂逼啦!所以我们首先需要通过过滤器将用户的数据读出来进行安全校验,这里面涉及到一个动作,就是需要将用户的数据在过滤器中读出来,进行校验,通过之后再放行。

    问题

    如果我们的数据是get请求倒还好,但是如果是一些数据量比较大,我们需要通过post json的方式来说传递数据的时候,这个时候其实是通过流的方式传递的,如果在过滤器中将参数读取出来之后,然后放行,等到到Servlet的时候,@RequestBody是无法获取到数据的,因为post json使用流传递,流被读取之后就不存在了,所以我们在过滤器中读取之后,@ReqeustBody自然就读不到数据了,同时会报如下一个错误。

    在过滤器中读取body中的数据

    @WebFilter

    @Slf4j

    public class CheckUserFilter implements Filter {

    @Override

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;

    // 在过滤器中读取数据

    BufferedReader reader = request.getReader();

    StringBuilder sb = new StringBuilder();

    String line;

    while ((line = reader.readLine()) != null) {

    sb.append(line);

    }

    reader.close();

    System.out.println(sb.toString());

    filterChain.doFilter(request, res);

    }

    }

    复制代码出现异常,就是说内容已经被读取了,你不能调用了

    {"id":"1","username":"bingfeng"}

    java.lang.IllegalStateException: UT010003: Cannot call getInputStream(), getReader() already called

    at io.undertow.servlet.spec.HttpServletRequestImpl.getInputStream(HttpServletRequestImpl.java:666)

    at javax.servlet.ServletRequestWrapper.getInputStream(ServletRequestWrapper.java:152)

    at javax.servlet.ServletRequestWrapper.getInputStream(ServletRequestWrapper.java:152)

    复制代码

    解决

    HttpServletRequestWrapper

    那么出现这种问题怎么办呢?能不能通过一个中间的变量将这些数据保存下来,然后我们就可以一直读取了,这样不就解决了这个问题了吗?那保存在哪里呢?这个时候 HttpServletRequestWrapper 就排上用场了。

    这个其实你可以把它理解为Request的包装类,Reqeust中有的方法它都有,我们通过继承这个类,重写该类中的方法,将body中的参数保存一个byte数组中,然后放行的时候将这个包装类传递进去,不就可以一直拿到参数了?

    封装Request类

    public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final byte[] body;

    /**

    * 所有参数的集合

    */

    private Map parameterMap;

    public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {

    super(request);

    BufferedReader reader = request.getReader();

    body = readBytes(reader);

    parameterMap = request.getParameterMap();

    }

    @Override

    public BufferedReader getReader() throws IOException {

    ServletInputStream inputStream = getInputStream();

    if (null == inputStream) {

    return null;

    }

    return new BufferedReader(new InputStreamReader(inputStream));

    }

    @Override

    public Enumeration getParameterNames() {

    Vector vector = new Vector<>(parameterMap.keySet());

    return vector.elements();

    }

    @Override

    public ServletInputStream getInputStream() throws IOException {

    if (body == null) {

    return null;

    }

    final ByteArrayInputStream bais = new ByteArrayInputStream(body);

    return new ServletInputStream() {

    @Override

    public boolean isFinished() {

    return false;

    }

    @Override

    public boolean isReady() {

    return false;

    }

    @Override

    public void setReadListener(ReadListener listener) {

    }

    @Override

    public int read() throws IOException {

    return bais.read();

    }

    };

    }

    /**

    * 通过BufferedReader和字符编码集转换成byte数组

    *

    * @param br

    * @return

    * @throws IOException

    */

    private byte[] readBytes(BufferedReader br) throws IOException {

    String str;

    StringBuilder retStr = new StringBuilder();

    while ((str = br.readLine()) != null) {

    retStr.append(str);

    }

    if (StringUtils.isNotBlank(retStr.toString())) {

    return retStr.toString().getBytes(StandardCharsets.UTF_8);

    }

    return null;

    }

    }

    复制代码将过滤器改造

    @WebFilter

    @Slf4j

    public class CheckUserFilter implements Filter {

    @Override

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;

    BodyReaderHttpServletRequestWrapper requestWrapper = new BodyReaderHttpServletRequestWrapper(request);

    // 从Request的包装类中读取数据

    BufferedReader reader = requestWrapper.getReader();

    StringBuilder sb = new StringBuilder();

    String line;

    while ((line = reader.readLine()) != null) {

    sb.append(line);

    }

    reader.close();

    System.out.println(sb.toString());

    filterChain.doFilter(requestWrapper, res);

    }

    }

    复制代码

    经过这样的配置之后,我们即使在过滤器中获取了参数,请求也会到达Servlet。

    如果基础知识IO那块不是很扎实的话,第一眼看到这个问题确实挺懵逼的。我也是百度之后解决的,确实值得记录一下,有时候我们会对所有请求进来的参数进行保存输出什么的,这个时候如果是post json数据的话,如果不是特别明白,可能也会出现这种问题。

    日拱一卒,功不唐捐

    更多内容请关注

    b739ec46bb5c46d9c0aa4ce35ba1ea56.png

    关于找一找教程网

    本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。

    本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。

    [@RequestBody参数已经被读取,究竟是何原因?]http://www.zyiz.net/tech/detail-137520.html

    展开全文
  • 想要在java代码里调用一个web接口,该接口通过postman测试是可以成功,如图: ![图片说明](https://img-ask.csdn.net/upload/201901/16/1547608544_517344.png) 但是以如下方式写在java代码里却无法成功,请问有...
  • 所有Collection结合都可以通过stream默认方法获取流; default Stream Stream() Stream接口静态方法of可以获取数组对应的流。 static Stream of (T…values) 参数是一个可变参数,那么我们就可以传递一个数组 ...

    1. 获取Stream流的方法

    java.util。stream.Stream是Java 8新加入的最常用的流接口。(这并不是一个函数式接口);
    获取一个流非常简单,有以下几种常用的方式获取流.

    • 所有的Collection结合都可以通过stream默认方法获取流;
      default Stream Stream()
    • Stream接口的静态方法of可以获取数组对应的流。
      static Stream of (T…values)
      参数是一个可变参数,那么我们就可以传递一个数组
    package com.Stream;
    
    import java.util.*;
    import java.util.stream.Stream;
    
    /*
        java.util。stream.Stream<T>是Java 8新加入的最常用的流接口。(这并不是一个函数式接口)
        获取一个流非常简单,有以下几种常用的方式获取流;
            所有的Collection结合都可以通过stream默认方法获取流;
                 default Stream<E> Stream()
            Stream接口的静态方法of可以获取数组对应的流。
                 static<T> Stream<T> of (T...values)
                 参数是一个可变参数,那么我们就可以传递一个数组
     */
    public class Demo03GetStream {
        public static void main(String[] args) {
            //把集合转换为Stream流
            List<String> list = new ArrayList<>();
            Stream<String> stream1 = list.stream();
    
            Set<String> set = new HashSet<>();
            Stream<String> stream2 = set.stream();
    
            Map<String,String> map = new HashMap<>();
            //获取键,存储到一个Set集合中
            Set<String> keySet = map.keySet();
            Stream<String> stream3 = keySet.stream();
    
            //获取值,存储到一个Collection集合中
            Collection<String> values = map.values();
            Stream<String> stream4 = values.stream();
    
            //获取键值对(键与值的映射关系 entrySet)
            Set<Map.Entry<String, String>> entries = map.entrySet();
    
            Stream<Map.Entry<String, String>> stream5 = entries.stream();
    
            //把数组转换为Stream流
            Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5, 6);
            //可变参数可以传递数组
            Integer[] arr = {1,2,3,4,5};
            Stream<Integer> stream7 = Stream.of(arr);
    
            String[] arr2 = {"a","dd","cc"};
            Stream<String> stream8 = Stream.of(arr2);
        }
    }
    
    

    2.Stream流中常用方法_forEach

    流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:

    • 延迟方法:返回值类型仍然是 Stream 接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方 法均为延迟方法。)
    • 终结方法:返回值类型不再是 Stream 接口自身类型的方法
    void forEach(Consumer<? super T> action);
    
    • 该方法接收一个Consumer接口函数,会将每一个流元素交给函数进行处理。
    • Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数据。
    • 简单记:
      forEach方法,用来遍历流中的数据;
      是一个终结方.法,遍历之后就不能继续调用Stream流中的其他方法。
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        Stream流中常用方法_forEach
        void forEach(Consumer<? super T> action);
        该方法接收一个Consumer接口函数,会将每一个流元素交给函数进行处理。
        Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数据
    
        简单记:
            forEach方法,用来遍历流中的数据
            是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法
     */
    public class Dem04Stream_forEach {
        public static void main(String[] args) {
            //获取一个Stream流
            Stream<String> stream = Stream.of("张三", "赵四", "王五", "李六", "田七");
            //使用Stream流中的方法forEach对Stream流中的数据进行遍历
        /*    stream.forEach((String name)->{
                System.out.println(name);
            });*/
            stream.forEach( name-> System.out.println(name));
        }
    }
    
    

    3.Stream流中的常用方法——filter:用于对Stream流中的数据进行过滤

    Stream<T> filter(Predicate<? super T> predicate);
    
    • filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤
    • Predicate中的抽象方法:
      boolean test(T t);
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        Stream流中的常用方法——filter:用于对Stream流中的数据进行过滤
        Stream<T> filter(Predicate<? super T> predicate);
        filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤
        Predicate中的抽象方法:
              boolean test(T t);
     */
    public class Demo05Stream_filter {
        public static void main(String[] args) {
            //创建一个Stream流
            Stream<String> stream = Stream.of("张三丰", "张翠山", "周芷若", "赵敏", "张无忌");
            //对Stream流中的元素进行过滤,只要姓张的人
           Stream stream2 = stream.filter((String name)->{return name.startsWith("张");});
           //遍历stream2
            stream2.forEach(name-> System.out.println(name));
    
            /*
            Stream流属于管道流,只能被消费(使用)一次
            第一个Stream流调用完毕方法,数据就会流转到下一个Stream上
            而这时第一个Stream流已经使用完毕,就会关闭了
            所以第一个Stream流就不能调用方法了
            IllegalStateException: stream has already been operated upon or closed
             */
            //遍历Stream流
            stream.forEach(name-> System.out.println(name));
        }
    }
    
    

    4.如果需要将流中的元素映射到另一个流中,可以使用map方法。

    <R> Stream<R> map(Function<? super T,? extends R> mapper);
    
    • 该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转化为另一种R类型的流。
    • Function中的抽象方法:
      R apply(T t);
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        如果需要将流中的元素映射到另一个流中,可以使用map方法。
        <R> Stream<R> map(Function<? super T,? extends R> mapper);
        该接口需要一个Function函数式接口参数,可以将当前流中的T类型数据转化为另一种R类型的流。
        Function中的抽象方法:
         R apply(T t);
     */
    public class Demo06Stream_map {
        public static void main(String[] args) {
            //获取一个String类型的Stream流
            Stream<String> stream = Stream.of("1", "2", "3", "4", "5", "6");
            //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
            Stream<Integer> stream2 = stream.map((String s)->{
               return Integer.parseInt(s);
            });
            //遍历stream2
            stream2.forEach(i-> System.out.println(i));
        }
    }
    
    

    5.Stream流中常用方法_count:用于统计Stream流中元素的个数

    • long count();
    • count方法是一个终结方法,返回值是一个long类型的整数;所以不能再继续调用Stream流中的其他方法了
    package com.Stream;
    
    import java.util.ArrayList;
    import java.util.stream.Stream;
    
    /*
        Stream流中常用方法_count:用于统计Stream流中元素的个数
        long count();
        count方法是一个终结方法,返回值是一个long类型的整数
        所以不能再继续调用Stream流中的其他方法了
     */
    public class Demo07Stream_count {
        public static void main(String[] args) {
            //获取一个Stream流
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            Stream<Integer> stream = list.stream();
            long count = stream.count();
            System.out.println(count);
        }
    }
    
    

    6.Stream流中常用方法——limit:用于截取流中的元素

    • limit方法可以对流进行截取,只取前n个。方法签名:
    Stream<T> limit(long maxSize);
    
    • 参数是一个long型,如果集合当前长度大于参数则进行截取,否则不进行操作
    • limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        Stream流中常用方法——limit:用于截取流中的元素
        limit方法可以对流进行截取,只取前n个。方法签名:
        Stream<T> limit(long maxSize);
             参数是一个long型,如果集合当前长度大于参数则进行截取,否则不进行操作
        limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法
     */
    public class Demo08Stream_limit {
        public static void main(String[] args) {
            //获取一个Stream流
            String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
            Stream<String> stream = Stream.of(arr);
            //使用limit方法对Stream流中的元素进行截取,只要前3个元素
            Stream<String> strean2 = stream.limit(3);
            //遍历stream2流
            strean2.forEach(name-> System.out.println(name));
        }
    }
    
    

    7.Stream流中常用方法——skip:用于跳过元素

    • 如果希望跳过前几个元素,可以使用skip方法获取一个截取之后的新流;
    Stream<T> skip(long n);
    
    • 如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        Stream流中常用方法——skip:用于跳过元素
        如果希望跳过前几个元素,可以使用skip方法获取一个截取之后的新流;
        Stream<T> skip(long n);
            如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流
     */
    public class Demo09Stream_skip {
        public static void main(String[] args) {
            //获取一个Stream流
            String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
            Stream<String> stream = Stream.of(arr);
            //使用skip方法跳过前3个元素
            Stream<String> stream2 = stream.skip(3);
    
            //遍历stream2流
            stream2.forEach(name-> System.out.println(name));
        }
    }
    
    

    8.Stream流中的常用方法——concat:用于把流组合到一起

    • 如果有两个流,希望合并成为一个流,那么可以使用静态方法concat
    static <T> Stream<T> concat (Stream<? extends T> a,Stream <? extends T> b)
    
    package com.Stream;
    
    import java.util.stream.Stream;
    
    /*
        Stream流中的常用方法——concat:用于把流组合到一起
        如果有两个流,希望合并成为一个流,那么可以使用静态方法concat
        static <T> Stream<T> concat (Stream<? extends T> a,Stream <? extends T> b)
     */
    public class Demo10Stream_concat {
        public static void main(String[] args) {
            //创建一个Stream流
            Stream<String> stream1 = Stream.of("张三丰", "张翠山", "周芷若", "赵敏", "张无忌");
            //获取一个Stream流
            String[] arr = {"美羊羊","喜羊羊","懒羊羊","灰太狼","红太狼","小灰灰"};
            Stream<String> stream2 = Stream.of(arr);
    
            //把以上两个流组合一个流
            Stream<String> concat = Stream.concat(stream1, stream2);
            //遍历concat
            concat.forEach(name-> System.out.println(name));
        }
    }
    
    
    展开全文
  • 直接获取数据:只需要打开一个...如果一POST方式获得数据,则需要setRequestMethod设置,然后将我们要传递的参数内容通过writeBytes方法写入数据。代码如下:Activity01.java:import android.app.Activity;i...

    直接获取数据:只需要打开一个HttpURLConnection连接,然后取得里面的数据,之后关闭这个连接

    以get方式获得数据,只要对地址直接加上要传递的参数即可。

    如果一POST方式获得数据,则需要setRequestMethod设置,然后将我们要传递的参数内容通过writeBytes方法写入数据流。代码如下:

    Activity01.java:

    import android.app.Activity;

    import android.content.Intent;

    import android.os.Bundle;

    import android.view.View;

    import android.widget.Button;

    public class Activity01 extends Activity

    {

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.main);

    Button button_http = (Button) findViewById(R.id.Button_HTTP);

    button_http.setOnClickListener(new Button.OnClickListener() {

    public void onClick(View v)

    {

    Intent intent = new Intent();

    intent.setClass(Activity01.this, Activity02.class);

    startActivity(intent);

    Activity01.this.finish();

    }

    });

    Button button_Get = (Button) findViewById(R.id.Button_Get);

    button_Get.setOnClickListener(new Button.OnClickListener() {

    public void onClick(View v)

    {

    Intent intent = new Intent();

    intent.setClass(Activity01.this, Activity03.class);

    startActivity(intent);

    Activity01.this.finish();

    }

    });

    Button button_Post = (Button) findViewById(R.id.Button_Post);

    button_Post.setOnClickListener(new Button.OnClickListener() {

    public void onClick(View v)

    {

    Intent intent = new Intent();

    intent.setClass(Activity01.this, Activity04.class);

    startActivity(intent);

    Activity01.this.finish();

    }

    });

    }

    }

    直接访问:Activity02.java

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.net.HttpURLConnection;

    import java.net.MalformedURLException;

    import java.net.URL;

    import android.app.Activity;

    import android.content.Intent;

    import android.os.Bundle;

    import android.util.Log;

    import android.view.View;

    import android.widget.Button;

    import android.widget.TextView;

    //直接获取数据

    public class Activity02 extends Activity

    {

    private final String DEBUG_TAG = "Activity02";

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.http);

    TextView mTextView = (TextView)this.findViewById(R.id.TextView_HTTP);

    //http地址

    String httpUrl = "http://www.baidu.com";

    //获得的数据

    String resultData = "";

    URL url = null;

    try

    {

    //构造一个URL对象

    url = new URL(httpUrl);

    }

    catch (MalformedURLException e)

    {

    Log.e(DEBUG_TAG, "MalformedURLException");

    }

    if (url != null)

    {

    try

    {

    //使用HttpURLConnection打开连接

    HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();

    //得到读取的内容(流)

    InputStreamReader in = new InputStreamReader(urlConn.getInputStream());

    // 为输出创建BufferedReader

    BufferedReader buffer = new BufferedReader(in);

    String inputLine = null;

    //使用循环来读取获得的数据

    while (((inputLine = buffer.readLine()) != null))

    {

    //我们在每一行后面加上一个"\n"来换行

    resultData += inputLine + "\n";

    }

    //关闭InputStreamReader

    in.close();

    //关闭http连接

    urlConn.disconnect();

    //设置显示取得的内容

    if ( resultData != null )

    {

    mTextView.setText(resultData);

    }

    else

    {

    mTextView.setText("读取的内容为NULL");

    }

    }

    catch (IOException e)

    {

    Log.e(DEBUG_TAG, "IOException");

    }

    }

    else

    {

    Log.e(DEBUG_TAG, "Url NULL");

    }

    //设置按键事件监听

    Button button_Back = (Button) findViewById(R.id.Button_Back);

    button_Back.setOnClickListener(new Button.OnClickListener()

    {

    public void onClick(View v)

    {

    Intent intent = new Intent();

    intent.setClass(Activity02.this, Activity01.class);

    startActivity(intent);

    Activity02.this.finish();

    }

    });

    }

    }

    POST方式传递:Activity04.java:

    import java.io.BufferedReader;

    import java.io.DataOutputStream;

    import java.io.IOException;

    import java.io.InputStreamReader;

    import java.net.HttpURLConnection;

    import java.net.MalformedURLException;

    import java.net.URL;

    import java.net.URLEncoder;

    import android.app.Activity;

    import android.content.Intent;

    import android.os.Bundle;

    import android.util.Log;

    import android.view.View;

    import android.widget.Button;

    import android.widget.TextView;

    //以post方式上传参数

    public class Activity04 extends Activity

    {

    private final String DEBUG_TAG = "Activity04";

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.http);

    TextView mTextView = (TextView)this.findViewById(R.id.TextView_HTTP);

    //http地址"?par=abcdefg"是我们上传的参数

    String httpUrl = "http://www.baidu.com";

    //获得的数据

    String resultData = "";

    URL url = null;

    try

    {

    //构造一个URL对象

    url = new URL(httpUrl);

    }

    catch (MalformedURLException e)

    {

    Log.e(DEBUG_TAG, "MalformedURLException");

    }

    if (url != null)

    {

    try

    {

    // 使用HttpURLConnection打开连接

    HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();

    //因为这个是post请求,设立需要设置为true

    urlConn.setDoOutput(true);

    urlConn.setDoInput(true);

    // 设置以POST方式

    urlConn.setRequestMethod("POST");

    // Post 请求不能使用缓存

    urlConn.setUseCaches(false);

    urlConn.setInstanceFollowRedirects(true);

    // 配置本次连接的Content-type,配置为application/x-www-form-urlencoded的

    urlConn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");

    // 连接,从postUrl.openConnection()至此的配置必须要在connect之前完成,

    // 要注意的是connection.getOutputStream会隐含的进行connect。

    urlConn.connect();

    //DataOutputStream流

    DataOutputStream out = new DataOutputStream(urlConn.getOutputStream());

    //要上传的参数

    String content = "par=" + URLEncoder.encode("ABCDEFG", "gb2312");

    //将要上传的内容写入流中

    out.writeBytes(content);

    //刷新、关闭

    out.flush();

    out.close();

    //获取数据

    BufferedReader reader = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));

    String inputLine = null;

    //使用循环来读取获得的数据

    while (((inputLine = reader.readLine()) != null))

    {

    //我们在每一行后面加上一个"\n"来换行

    resultData += inputLine + "\n";

    }

    reader.close();

    //关闭http连接

    urlConn.disconnect();

    //设置显示取得的内容

    if ( resultData != null )

    {

    mTextView.setText(resultData);

    }

    else

    {

    mTextView.setText("读取的内容为NULL");

    }

    }

    catch (IOException e)

    {

    Log.e(DEBUG_TAG, "IOException");

    }

    }

    else

    {

    Log.e(DEBUG_TAG, "Url NULL");

    }

    Button button_Back = (Button) findViewById(R.id.Button_Back);

    button_Back.setOnClickListener(new Button.OnClickListener()

    {

    public void onClick(View v)

    {

    Intent intent = new Intent();

    intent.setClass(Activity04.this, Activity01.class);

    startActivity(intent);

    Activity04.this.finish();

    }

    });

    }

    }

    展开全文
  • 所有Collection集合都可以通过stream默认方法获取流; default Stream stream ()。 Stream接口静态方法of可以获取数组对应的流; static Stream of (T… values)。 参数是一个可变参数,那么我们就可以传递一个...

    Stream流与数组集合的转换

    java. util. stream. Stream是Java 8新加入的最常用的流接口。(这并不是一个函数式接口。)
    获取一个流非常简单,有以下几种常用的方式:

    所有的Collection集合都可以通过stream默认方法获取流;
        default Stream stream ()。

    Stream接口的静态方法of可以获取数组对应的流;
        static Stream of (T… values)。

    参数是一个可变参数,那么我们就可以传递一个数组。
    以下则是集合与数组转变为流的方式:

    public class StreamDemo {
    
    	public static void main(String[] args) {
    		List<String> list = new ArrayList<>();
    		Stream<String> s1 = list.stream();
    
    		Set<String> set = new HashSet<>();
    		Stream<String> s2 = set.stream();
    
    		Map<String,String> map = new HashMap<>();
    
    		//获取键,存储到- -个Set集合中
    		Set<String> keySet = map. keySet();
    		Stream<String> s3 = keySet.stream();
    
    		//获取值,存储到一-个Col lection集合中
    		Collection<String> values = map. values();
    		Stream s4 = values.stream();
    
    		//获取键值对(键与值的映射关系entrySet)
    		Set<Map. Entry<String,String>> entries = map.entrySet();
    		Stream<Map. Entry<String, String>> s5
    		= entries. stream();
    		
    		//把数组转换为Stream流
    		Stream<Integer> s6 = Stream.of(1, 2, 3, 4, 5);
    		//可变参数传递数组
    		Integer[] arr = {1,2,3,4,5};
    		Stream<Integer> s7 = Stream.of(arr);
    		String[] arr2 = {"a","bb","CCC"};
    		Stream<String> s8 = Stream.of(arr2);
    	}
    }
    

    一次性消费方法forEach

    Stream流中的常用方法_ forEach
        void forEach(Consumer<? super T> action);
            该方法接收- -个Consumer接口函数,会将每- -个流元素交给该函数进行处理。
        Consumer接口是一个消费型的函数式接口,可以传递L ambda表达式,消费数据
    简单记:
        forEach方法,用来遍历流中的数据是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法

    Stream流中的常用方法filter:
        用于对Stream流中的数据进行过滤
    Stream filter(Predicate<? super T> predicate);
        filter方法的参数Predicate是一个函数式接口, 所以可以传递L ambda表达式,对数据进行过滤
    Predicate中的抽象方法:
        boolean test(T t);

        Stream流属于管道流,只能被消费(使用)一次第一个Stream流调用完毕方法,数据就会流转到下一个Stream上而这时第一个Stream流 已经使用完毕,就会关闭了所以第-个Stream流就不能再调用方法了

    public class Practice {
    
    	public static void main(String[] args) {
    		String[] a = {"大佬","二老","三老","四老","五老"};
    		Stream<String> s1 = Stream.of(a);
    		//s1.forEach((String name)->{System.out.print(name);});
    		s1.forEach((String name)->System.out.print(name+" "));	
    	}
    }
    

    运行结果:

    大佬 二老 三老 四老 五老 
    
    若“//s1.forEach((String name)->{System.out.print(name);});”这行没有给注释掉,即有两个forEach方法;运行结果则会报错,如下
    大佬二老三老四老五老Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    	at java.base/java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
    	at java.base/java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:658)
    	at cn.yunhe.weekend.Practice.main(Practice.java:10)
    

    故forEach为Stream流中的最终方法即一次性方法。

    展开全文
  • 在并行处理中,我们可以将合并器函数作为附加参数传递给该方法。 Stream reduce()可用于获取存储在集合中数字总和。 Stream reduce()还可以用给定分隔符连接存储在集合中字符串数据。 Stream reduce()方法...
  • 直接获取数据:只需要打开一个...如果一POST方式获得数据,则需要setRequestMethod设置,然后将我们要传递的参数内容通过writeBytes方法写入数据。代码如下:Activity01.java:import android.app.Activity;i...
  • -所有Collection集合都可以通过stream默认方法获取流; default Stream stream( ) -Stream接口静态方法可以获取数组对应的流。 static Stream of (T…values) 参数是一个可变参数,那么我们就可以传递一个数组 ...
  • java程序开发中经常用到与服务端的交互工作,主要的就是传递相应的参数请求从而获取到对应的结果加以处理 可以使用Get请求与Post请求,注意!这里的Get请求不是通过浏览器界面而是在程序代码中设置的,达到Get...
  • Web服务器的java实现

    热门讨论 2013-02-15 23:06:47
    HTTP请求一般是GET或POST命令(POST用于FORM参数的传递)。GET命令格式为:  GET 路径/文件名 HTTP/1.0  文件名指出所访问文件,HTTP/1.0指出Web浏览器使用HTTP版本。  (3) 应答:Web浏览器提交请求后...
  • 7.3.1 方法的参数:让汽车可以加速 161 7.3.2 带参数的方法有何不同? 162 7.3.3 让方法有多个参数 163 7.4 返回值:汽车超速了吗? 164 7.4.1 写一个有返回值的方法 164 7.4.2 调用有返回值的方法 165 7.4.3 ...
  • C#调用JavaWebService

    热门讨论 2013-10-28 10:25:04
    然后自动产生代理类,但是在调用JAVA的WebService时并没有这么简单,特别是对于SoapHeader的处理,通过C#添加Web引用方式访问JavaWebService的方法,除了string类型能正常传递参数外,q其他类型的参数不是默认值就是...
  • 如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。 18、error和exception有什么区别?  error 表示恢复...
  • 7.3.1 方法的参数:让汽车可以加速 161 7.3.2 带参数的方法有何不同? 162 7.3.3 让方法有多个参数 163 7.4 返回值:汽车超速了吗? 164 7.4.1 写一个有返回值的方法 164 7.4.2 调用有返回值的方法 165 7.4.3 ...
  • 7.3.1 方法的参数:让汽车可以加速 161 7.3.2 带参数的方法有何不同? 162 7.3.3 让方法有多个参数 163 7.4 返回值:汽车超速了吗? 164 7.4.1 写一个有返回值的方法 164 7.4.2 调用有返回值的方法 165 7.4.3 ...
  • 基于JAVA的搜索引擎 lucene-2.2.0

    热门讨论 2011-11-15 07:47:11
    * 该方法中的参数列表中。各个参数的含义如下: * d :指定的存放建立索引文件的索引目录 * a :一个传递进来分析器 * create :是否要重新写入索引文件,如果为true,则重写索引文件;如果为false,则追加写入索引...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    constructWithPara.java参数的构造方法 declareDefault.java 缺省访问权限使用 declarePrivate.java 私有访问权限使用 declareProtected.java 保护访问权限使用 deriveClass.java 子类访问父类变量...
  • *******************************提供接口**************************************//通过request的输入获取调用接口传递过来的参数// 遍历request的public String getRequestStreamString(InputStream is) {...
  • Java2核心技术第7版全两卷.pdf中文高清

    千次下载 热门讨论 2012-09-14 14:22:28
    7.13.6 通过系统剪贴板传递java对象 514 7.14 拖放操作 517 7.14.1 放置目标 519 7.14.2 拖曳源 526 7.14.3 swing对数据传递的支持 531 第8章 javabean构件 534 8.1 为何是bean 534 8.2 编写bean的过程 535 ...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    9.1.1 运行Java程序的参数 315 9.1.2 使用Scanner获取键盘输入 316 9.1.3 使用BufferedReader获取键盘输入 318 9.2 系统相关 319 9.2.1 System类 319 9.2.2 Runtime类 321 9.3 常用类 322 9.3.1 Object类 322...
  • java 面试题 总结

    2009-09-16 08:45:34
    如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。 15、error和exception有什么区别? error 表示恢复不是...
  • 现在,Java EE 后端与 Flex 前端接口已经定义好了,要完成 Java EE 后端接口实现类非常容易,利用 Spring 强大依赖注入功能,可以通过几行简单代码完成: 清单 2. FlexServiceImpl class public ...
  • 通过 RemoteObject 进行调用虽然简单,但存在不少问题:首先,RemoteObject 是一个 Dynamic Class,Flex Builder 编译器无法替我们检查参数类型和参数个数,这样,在编写 ActionScript 代码时极易出错。...
  • //传递过来soket参数赋予给socket对象 } public void run() {//run()函数用来实现线程要完成任务 startHeartBeatThread(); while(run_flag) { try { String str = null; is = ...
  • java面试宝典

    2013-02-28 16:04:01
    179、页面间对象传递的方法 42 180、JSP和Servlet有哪些相同点和不同点,他们之间的联系是什么? 42 181、四种会话跟踪技术 42 182、Request对象的主要方法 43 183、我们在web应用开发过程中经常遇到输出某种编码的...
  • [code="java"]*******************************提供...//通过request的输入获取调用接口传递过来的参数 // 遍历request的 public String getRequestStreamString(InputStream is) { try {...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    对于java流的认识 28.简单描述一下awt与swing区别。 29.简述java编程中事件处理模式。 30.你编写过applet吗?applet安全权限如何?试列举java application或者applet中与servlet/jsp通信可以采用方式。 31...
  • Java经典编程300例(code)

    千次下载 热门讨论 2013-01-09 10:26:53
    实例002 输出控制台传递的参数 2 实例003 输出由“*”组成的三角形 3 实例004 输出符号表情 5 第2章 Eclipse开发工具 6 实例005 下载并运行Eclipse工具 7 实例006 为Eclipse安装汉化包 8 实例007 使用Eclipse注释...
  • java核心技术第八版(1,2卷)源码

    千次下载 热门讨论 2009-04-04 21:04:35
     7.13.5 通过系统剪贴板传递Java对象  7.13.6 使用本地剪贴板来传递对象引用  7.14 拖放操作  7.14.1 Swing对数据传递的支持  7.14.2 拖曳源  7.14.3 放置目标  7.15 平台集成  7.15.1 闪屏  7.15.2 启动...

空空如也

空空如也

1 2 3 4 5 6
收藏数 102
精华内容 40
关键字:

java获取通过流传递的参数

java 订阅