8.14 学习笔记

最新推荐文章于 2025-11-26 22:42:35 发布

原创最新推荐文章于 2025-11-26 22:42:35 发布 · 165 阅读

0 ·

CC 4.0 BY-SA版权

1.

静态变量以及被transient修饰的变量属于类的状态，序列化保存的是对象的状态，不能保存上述两种变量。

2.

网友回答：

泛型只是在 *编译期* 保证对象类型相同的技术。

真正在代码的运行期，jvm会擦出泛型的存在。

所以我们可以利用反射技术为一个已指定泛型的集合添加一个不符合泛型要求的元素，因为反射的生效期在运行期，泛型无法进行拦截。

因此，泛型指定的元素不具有继承的特性。不能将泛型中的派生类类型复制给基类类型。

因此BEF错误。

从而出现了通配符的技术，为了解决在泛型中不能像正常JAVA类中的继承关系。

我个人的理解是通配符的继承就是为了弥补泛型在继承关系上面的缺陷而诞生的。

因此集合可以使用通配符来描述继承关系，但不能直接使用指定泛型来描述。

通配符的方式可以正确的描述带泛型集合的继承关系。

因此CDG正确 。

3.hashtable和hashmap的区别

hashtable是线程安全的，hashmap不是。hashmap的迭代器iterator是fail-fast机制，如果有其他线程改变了它的该机制就会尽量抛出异常，但是迭代器本身的remove()方法一出元素不会抛出，而hashtable的迭代器enumerator则不会抛出异常。hashtable直接使用对象的hashCode，hashmap重新计算对象的hashCode。hashmap可以允许KV为null，在hashmap中不能用get（）判断其是否有某个键（因为该方法返回null时可能表示没有该键或者是有null这个键），所以使用containsKey()判断其中是否有该键。

4.汉诺塔递归实现

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class HanNuoTa {
    public static void main(String[] args)
    {
        while (true)
        {
            BufferedReader reader = new BufferedReader((new InputStreamReader(System.in)));
            String s = null;
            try {
                s = reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }

            int n = Integer.parseInt(s);
            String a = "a";
            String b = "b";
            String c = "c";

            hannuota(n, a, b, c);
        }

    }

    public static void hannuota(int n, String a, String b, String c)
    {
        if (1 == n)
        {
            System.out.println("将编号为" + n + "的盘子" + "从" + a + "柱子移到" + c + "柱子");
        }
        else
        {
            hannuota(n-1, a, c, b);
            System.out.println("将编号为" + n + "的盘子" + "从" + a + "柱子移到" + c + "柱子");
            hannuota(n-1, b, a, c);
        }
    }
}

5.解决乱码的究极工具类

package com.kuang.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**

 * 解决get和post请求 全部乱码的过滤器
   */
   public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
   }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 对request包装增强
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);

   }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
   }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {
private HttpServletRequest request;
//是否编码的标记
private boolean hasEncode;
//定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
public MyRequest(HttpServletRequest request) {
    super(request);// super必须写
    this.request = request;
}
 
// 对需要增强方法 进行覆盖
@Override
public Map getParameterMap() {
    // 先获得请求方式
    String method = request.getMethod();
    if (method.equalsIgnoreCase("post")) {
        // post请求
        try {
            // 处理post乱码
            request.setCharacterEncoding("utf-8");
            return request.getParameterMap();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    } else if (method.equalsIgnoreCase("get")) {
        // get请求
        Map<String, String[]> parameterMap = request.getParameterMap();
        if (!hasEncode) { // 确保get手动编码逻辑只运行一次
            for (String parameterName : parameterMap.keySet()) {
                String[] values = parameterMap.get(parameterName);
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        try {
                            // 处理get乱码
                            values[i] = new String(values[i]
                                    .getBytes("ISO-8859-1"), "utf-8");
                        } catch (UnsupportedEncodingException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            hasEncode = true;
        }
        return parameterMap;
    }
    return super.getParameterMap();
}
 
//取一个值
@Override
public String getParameter(String name) {
    Map<String, String[]> parameterMap = getParameterMap();
    String[] values = parameterMap.get(name);
    if (values == null) {
        return null;
    }
    return values[0]; // 取回参数的第一个值
}
 
//取所有值
@Override
public String[] getParameterValues(String name) {
    Map<String, String[]> parameterMap = getParameterMap();
    String[] values = parameterMap.get(name);
    return values;
}
}

6.如何写工具类（不要重复造轮子！）

先编写了getJson(Object object, String dateFormat)之后，如何再利用它编写getJson(Object object)这一重载方法

package com.yan.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
    public static String getJson(Object object)
    {
        getJson(object, "yyyy-MM-dd HH:mm:ss");
    }


    public static String getJson(Object object, String dateFormat)
    {
        ObjectMapper mapper = new ObjectMapper();

//        使用ObjectMapper来格式化输出，关闭时间戳方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//        自定义日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        return null;
    }
}