提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
提示：以下是本篇文章正文内容，下面案例可供参考
一、List使用
package com.ycy.collect;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.util.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
// list
public class CollectList {
// 数据初始化
// 方式1 该方式初始化的集合元素不可改变
List<Integer> integers = Arrays.asList(1, 3, 4, 5, 6);
// 方式2
List<Integer> integers2 = new ArrayList<Integer>() {{
add(1);
add(2);
add(3);
}};
// 方式3
List<Integer> integers3 = new ArrayList();
// 方式4
ArrayList<Integer> integers4 = new ArrayList<>(Collections.nCopies(5, 3));
// 方式5
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
public static void main(String[] args) {
// test1();
// test2();
// test3();
// test4();
// test5();
// test7();
test8();
}
public static void test1() {
// 如果使用这种方式初始化会报错
// List<String> aList = Arrays.asList("A", "B", "C", "D");
// List<String> bList = Arrays.asList("C", "D", "E", "F");
List<String> listA = new ArrayList<String>();
List<String> listB = new ArrayList<String>();
listA.add("A");
listA.add("B");
listA.add("C");
listA.add("D");
listB.add("C");
listB.add("D");
listB.add("E");
listB.add("F");
//交集
listA.retainAll(listB);
System.out.println(listA);
}
public static void test2() {
List<String> aList = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
List<String> bList = new ArrayList<>(Arrays.asList("C", "D", "E", "F"));
//差集
aList.removeAll(bList);
System.out.println(aList);
}
public static void test3() {
List<String> aList = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
List<String> bList = new ArrayList<>(Arrays.asList("C", "D", "E", "F"));
//并集
aList.removeAll(bList);
aList.addAll(bList);
System.out.println(aList);
}
public static void test4() {
// 异或 = 并集- 交集
List<String> aList = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
List<String> bList = new ArrayList<>(Arrays.asList("C", "D", "E", "F"));
// 交集
List cList = new ArrayList(aList);
cList.retainAll(bList);
// 并集
aList.removeAll(bList);
aList.addAll(bList);
// 并集 - 交集
aList.removeAll(cList);
System.out.println(aList);
}
// 对象集合处理 方式一 重写对象的 equals 和 hashcode 方法
public static void test5() {
List<User> users1 = new ArrayList<>();
List<User> users2 = new ArrayList<>();
for (int i = 1; i < 5; i++) {
User user = new User();
user.setId(i + "");
user.setName("tom" + i);
users1.add(user);
}
for (int i = 3; i < 7; i++) {
User user = new User();
user.setId(i + "");
user.setName("tom" + i);
users2.add(user);
}
// 交集
users1.retainAll(users2);
for (User user : users1) {
System.out.println(user.toString());
}
}
// 对象集合处理 方式二 使用唯一键比较
public static void test7() {
List<User2> users1 = new ArrayList<>();
List<User2> users2 = new ArrayList<>();
for (int i = 1; i < 5; i++) {
User2 user = new User2();
user.setId(i + "");
user.setName("tom" + i);
user.setDistinctKey(i + "tom" + i);
users1.add(user);
}
for (int i = 3; i < 7; i++) {
User2 user = new User2();
user.setId(i + "");
user.setName("tom" + i);
user.setDistinctKey(i + "tom" + i);
users2.add(user);
}
// 取并集 去重
users1.addAll(users2);
List<User2> collect = users1.stream().filter(distinctByKey(User2::getDistinctKey)).collect(Collectors.toList());
for (User2 user2 : collect) {
System.out.println(user2);
}
}
// 遍历list
public static void test8(){
List<User2> users1 = new ArrayList<>();
for (int i = 1; i < 5; i++) {
User2 user = new User2();
user.setId(i + "");
user.setName("tom" + i);
user.setDistinctKey(i + "tom" + i);
users1.add(user);
}
// 增强for
for (User2 user2 : users1) {
System.out.println(user2);
}
// 普通for循环
for (int i= 0;i<users1.size();i++){
System.out.println(users1.get(i));
}
// 转数组
Object[] objects = users1.toArray();
for (Object object : objects) {
System.out.println(object);
}
// 迭代器 通过迭代器遍历时可以删除集合中的元素
Iterator iterator = users1.iterator();
while(iterator.hasNext()) {
Object next = iterator.next();
Object name = getFieldValueByName("name", next);
if (!StringUtils.isEmpty(name) && name.equals("tom2")){
iterator.remove();
continue;
}
System.out.println(iterator.next());
}
}
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Set<Object> seen = ConcurrentHashMap.newKeySet();
return t -> seen.add(keyExtractor.apply(t));
}
private static Object getFieldValueByName(String fieldName, Object o) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[]{});
Object value = method.invoke(o, new Object[]{});
return value;
} catch (Exception e) {
return null;
}
}
public void setFieldValueByName(Object obj, String fieldName, Object value) {
try {
// 获取obj类的字节文件对象
Class c = obj.getClass();
// 获取该类的成员变量
Field f = c.getDeclaredField(fieldName);
// 取消语言访问检查
f.setAccessible(true);
// 给变量赋值
f.set(obj, value);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class User {
private String id;
private String name;
@Override
public boolean equals(Object obj) {
User u = (User) obj;
return id.equals(u.getId()) && name.equals(u.getName());
}
@Override
public int hashCode() {
return id.hashCode();
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class User2 {
private String id;
private String name;
private String distinctKey;
public User2(String id, String name) {
this.id = id;
this.name = name;
}
}
二、Map 使用
package com.ycy.collect;
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
public class CollectMap {
// map初始化 方式一
Map<String,String> map1 = new HashMap<>();
// 方式二
Map<String,String > map2 = new HashMap<String, String>(){{
put("1","tom");
put("2","jerry");
}};
// 方式三
Map<String, Integer> myMap = ImmutableMap.of("a", 1, "b", 2, "c", 3);
public static void main(String[] args) {
// test1();
test2();
}
// map常用方法
public static void test1(){
Map<String,String> map = new HashMap();
// 添加元素
map.put("name","tom");
map.put("age","12");
// 获取对应的值
map.get("name");
map.getOrDefault("hahaha","default");
// 判断是否存在指定的映射
boolean name = map.containsKey("name");
// 判断是否存在指定值的映射
boolean b = map.containsValue("12");
// 删除元素
map.remove("age");
// 返回所有值
Collection<String> values = map.values();
// 获取所有key
Set<String> strings = map.keySet();
// 返回map大小
int size = map.size();
// 清空map
map.clear();
}
// 便利 map
public static void test2(){
Map<String,String> map = new HashMap();
map.put("name","tom");
map.put("age","12");
map.put("sex","男");
map.put("weight","50");
// 方式一 foreach + lambda 表达式
map.forEach((k,v)->{
System.out.println(k+":"+v);
});
System.out.println("===================");
// 方式二 entrySet + 迭代器
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<String, String> next = iterator.next();
System.out.println(next.getKey()+":"+next.getValue());
}
System.out.println("===================");
// 方式三 entrySet + foreach
for (Map.Entry<String, String> stringStringEntry : map.entrySet()) {
System.out.println(stringStringEntry.getKey()+":"+stringStringEntry.getValue());
}
System.out.println("===================");
// 方式四 keySet + 迭代器
Set<String> strings = map.keySet();
Iterator<String> iterator1 = strings.iterator();
while (iterator1.hasNext()){
String next = iterator1.next();
System.out.println(next+":"+map.get(next));
}
System.out.println("===================");
// 方式四 keySet + foreach
Set<String> strings1 = map.keySet();
for (String key : strings1) {
System.out.println(key+":"+map.get(key));
}
}
private static Object getFieldValueByName(String fieldName, Object o) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[]{});
Object value = method.invoke(o, new Object[]{});
return value;
} catch (Exception e) {
return null;
}
}
public void setFieldValueByName(Object obj, String fieldName, Object value) {
try {
// 获取obj类的字节文件对象
Class c = obj.getClass();
// 获取该类的成员变量
Field f = c.getDeclaredField(fieldName);
// 取消语言访问检查
f.setAccessible(true);
// 给变量赋值
f.set(obj, value);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
三 Stream 流使用
package com.ycy.stream;
import com.mysql.cj.util.StringUtils;
import com.sun.org.apache.bcel.internal.generic.NEW;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.ibatis.annotations.Param;
import tk.mybatis.mapper.util.StringUtil;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
/**
* @author: luck
* @date: 2024/2/21 11:12
* @Description:
*/
public class Stream {
public static void main(String[] args) {
// test1();
// test2();
// test3();
// test4();
// test5();
// test7();
// test8();
// test9();
// test11();
// test12();
test13();
}
// 过滤
public static void test1() {
Arrays.asList(1, 2, 3, 4, 5).stream().filter(x -> x - 3 > 0).forEach(System.out::println);
}
// 使用map过滤
public static void test2() {
Arrays.asList(1, 2, 3, 4, 5).stream().map(x -> "Hello" + x).forEach(System.out::println);
}
// forEach
public static void test3() {
Arrays.asList(1, 2, 3, 4, 5).stream().map(x -> Arrays.asList(x, x)).forEach(System.out::println);
}
public static void test4() {
Arrays.asList("1", "2", "3").stream().mapToDouble(Double::parseDouble).forEach(System.out::println);
}
public static void test5() {
// 相当于二维数组
final List<List<String>> lists = Arrays.asList(
Arrays.asList("Hello World !!!", "I am Tom", "How are you doing?"),
Arrays.asList("1", "2", "3"),
Arrays.asList("你好世界！！！", "我是tom", "你正在做什么？")
);
lists.stream().flatMap(x -> x.stream()).forEach(System.out::println);
lists.stream().map(x -> x.stream()).forEach(System.out::println);
}
// 去重
public static void test6() {
Arrays.asList(1, 2, 5, 6, 8, 3, 6).stream().distinct().forEach(System.out::println);
}
// 排序
public static void test7() {
Arrays.asList("21", "25", "54", "12", "33").stream().sorted(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.parseInt(o1) - Integer.parseInt(o2);
}
}).forEach(System.out::println);
}
// 对象排序
public static void test11() {
List<User> userList = new ArrayList<>();
for (int i = 1; i < 6; i++) {
User user = new User();
user.setName("tom" + i);
user.setAge(i);
user.setSex(i % 2 == 0 ? "男" : "女");
userList.add(user);
}
User user1 = new User();
userList.add(new User("kk", "男", 12));
userList.add(new User(null, "男", 8));
// 排序 姓名升序 姓名为null认为排下 年龄降序
List<User> collect = userList.stream().sorted(
Comparator.comparing(User::getName, Comparator.nullsLast(String::compareTo))
.thenComparing(User::getAge, Comparator.nullsLast(Integer::compareTo).reversed())
).collect(Collectors.toList());
for (User user : collect) {
System.out.println(user.toString());
}
}
// 对象过滤
public static void test12() {
List<User> userList = new ArrayList<>();
for (int i = 1; i < 6; i++) {
User user = new User();
user.setName("tom" + i);
user.setAge(i);
user.setSex(i % 2 == 0 ? "男" : "女");
userList.add(user);
}
List<User> collect = userList.stream().filter(
d -> !StringUtil.isEmpty(d.getName())
&& d.getAge() > 3
&& d.getSex().equals("男")
).collect(Collectors.toList());
for (User user : collect) {
System.out.println(user);
}
}
// 对象去重
public static void test13(){
List<User> userList = new ArrayList<>();
for (int i = 1; i < 8; i++) {
User user = new User();
user.setName("tom" + i);
user.setAge(i);
user.setSex(i % 2 == 0 ? "男" : "女");
userList.add(user);
}
User user1 = new User();
user1.setName("tom2");
user1.setAge(2);
userList.add(user1);
System.out.println("去重前");
for (User user : userList) {
System.out.println(user.toString());
}
for (User user : userList) {
user.setDistinctKey(user.getName()+user.getAge());
}
List<User> collect = userList.stream().filter(distinctByKey(User::getDistinctKey)).collect(Collectors.toList());
System.out.println("去重后");
for (User user : collect) {
System.out.println(user.toString());
}
}
// 转 map
public static void test8() {
final ArrayList<User> users = new ArrayList<>();
for (int i = 0; i < 3; i++) {
users.add(User.builder().name(String.valueOf(i)).sex("男").age(11).build());
}
Map<String, Integer> collect = users.stream().collect(Collectors.toMap(k -> k.getName(), v -> v.getAge()));
collect.forEach((k, v) -> {
System.out.println(k + ":" + v);
});
}
public static void test20() {
final ArrayList<User> users = new ArrayList<>();
for (int i = 0; i < 3; i++) {
users.add(User.builder().name(String.valueOf(i)).sex("男").age(11).build());
}
// 当存在重复数据时，保留第一个元素
Map<String, Integer> collect = users.stream().collect(Collectors.toMap(User::getName,User::getAge,(value1, value2) -> value1));
collect.forEach((k, v) -> {
System.out.println(k + ":" + v);
});
}
// 分组
public static void test9() {
// 按照年龄进行分组，得到一个Map
final Map<Integer, List<UserOnlyAge>> collect = Arrays.asList(
UserOnlyAge.builder().age(1).build(),
UserOnlyAge.builder().age(2).build(),
UserOnlyAge.builder().age(1).build(),
UserOnlyAge.builder().age(2).build(),
UserOnlyAge.builder().age(5).build()
).stream().collect(Collectors.groupingBy(UserOnlyAge::getAge));
collect.forEach((k, v) -> {
System.out.println(k);
for (UserOnlyAge userOnlyAge : v) {
System.out.println(userOnlyAge.getAge());
}
});
}
//
public static void test10() {
IntStream.rangeClosed(1, 10).forEach(System.out::println);
IntStream.rangeClosed(1, 10).limit(4).forEach(System.out::println);
IntStream.rangeClosed(1, 10).skip(2).limit(4).forEach(System.out::println);
}
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Set<Object> seen = ConcurrentHashMap.newKeySet();
return t -> seen.add(keyExtractor.apply(t));
}
}
@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
class User {
private String name;
private String sex;
private int age;
private String distinctKey;
public User(String name, String sex, int age) {
this.name =name;
this.age = age;
this.sex = sex;
}
}
@Data
@Builder
class UserOnlyAge {
int age;
}
四 fastJson 使用
- 依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.47</version>
</dependency>
package com.ycy.collect;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.util.CollectionUtils;
import java.util.*;
public class FastJson {
// json数据
static String userJson = "{\n" +
"\"name\":\"tom\",\n" +
"\"age\":16,\n" +
"\"sex\":\"男\"\n" +
"}";
static String userJsonList = "[\n" +
"{\n" +
"\"name\":\"tom\",\n" +
"\"age\":16,\n" +
"\"sex\":\"男\"\n" +
"},{\n" +
"\"name\":\"jerry\",\n" +
"\"age\":15,\n" +
"\"sex\":\"女\"\n" +
"}\n" +
"]";
static String userObject = "{\n" +
" \"1\": {\n" +
" \"age\": 15,\n" +
" \"name\": \"tom\",\n" +
" \"sex\": \"男\"\n" +
" },\n" +
" \"2\": {\n" +
" \"age\": 16,\n" +
" \"name\": \"jerry\",\n" +
" \"sex\": \"男\"\n" +
" }\n" +
"}";
public static void main(String[] args) {
// test1();
// test2();
// test3();
// test4();
// test5();
// test6();
// test7();
// test8();
// test9();
test10();
}
// fastJson 常用方法
// public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
public static void test1(){
Object object = JSON.parse(userJson);
System.out.println(object.toString());
}
// public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject
public static void test2(){
JSONObject jsonObject = JSON.parseObject(userJson);
System.out.println(jsonObject.toString());
// jsonObject
jsonObject.put("name","hani");
jsonObject.put("sex","女");
System.out.println(jsonObject);
}
// public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean
public static void test3(){
User3 user3 = JSON.parseObject(userJson, User3.class);
System.out.println(user3.toString());
}
// public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
public static void test4(){
JSONArray objects = JSON.parseArray(userJsonList);
if (!CollectionUtils.isEmpty(objects)){
for (Object object : objects) {
System.out.println(object.toString());
}
}
}
// public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合
public static void test5(){
List<User3> user3s = JSON.parseArray(userJsonList, User3.class);
if (!CollectionUtils.isEmpty(user3s)){
for (User3 user3 : user3s) {
System.out.println(user3.toString());
}
}
}
// public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
// public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
public static void test6(){
List<User3> user3s = new ArrayList<>();
for (int i =1;i<4;i++){
User3 user3 = new User3("tom"+i,15,"男");
user3s.add(user3);
}
String s = JSON.toJSONString(user3s);
String s1 = JSON.toJSONString(user3s,true);
String s2 = JSON.toJSONString(user3s,false);
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
}
// public static final Object toJSON(Object javaObject); //将JavaBean转换为JSONObject或者JSONArray。
public static void test7(){
List<User3> user3s = new ArrayList<>();
for (int i =1;i<4;i++){
User3 user3 = new User3("tom"+i,15,"男");
user3s.add(user3);
}
Object o = JSON.toJSON(user3s);
System.out.println(o.toString());
}
// 操作json对象
public static void test8(){
JSONObject jsonObject = JSON.parseObject(userJson);
// 获取 jsonObject 属性
Object name = jsonObject.get("name");
Integer age = jsonObject.getInteger("age");
String sex = jsonObject.getString("sex");
System.out.println(name+"："+age+":"+sex);
// 设置 jsonObject 属性
jsonObject.put("name","jerry");
jsonObject.put("age",15);
jsonObject.put("sex","女");
System.out.println(jsonObject.toString());
}
// jsonArray 与 list 的项目转换
public static void test9(){
// jsonArray 转 list
JSONArray objects = JSON.parseArray(userJsonList);
List<User3> user3s = objects.toJavaList(User3.class);
if (!CollectionUtils.isEmpty(user3s)){
for (User3 user3 : user3s) {
System.out.println(user3.toString());
}
}
// list 转 jsonArray 现转为 string 再转为 jsONArray
List<User3> user3list = new ArrayList<>();
for (int i =1;i<4;i++){
User3 user3 = new User3("tom"+i,15,"男");
user3list.add(user3);
}
JSONArray objects1 = JSON.parseArray(JSON.toJSONString(user3list));
if (!CollectionUtils.isEmpty(objects1)){
for (Object o : objects1) {
System.out.println(o.toString());
}
}
}
// jsonObject 与 map 的项目转换
public static void test10(){
// sonObject 转 map
JSONObject jsonObject = JSON.parseObject(userObject);
Map<String, Object> innerMap = jsonObject.getInnerMap();
Set<String> keys = innerMap.keySet();
Iterator<String> iterator = keys.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next()+":"+innerMap.get(iterator.next()).toString());
}
for (String key : keys) {
System.out.println(key+":"+innerMap.get(key));
}
// map 转 jsonObject
Map<String,User3> user3Map = new HashMap<>();
for (int i =1;i<4;i++){
User3 user3 = new User3("tom" + i, 15, "男");
user3Map.put(""+i,user3);
}
JSONObject jsonObject1 = JSON.parseObject(JSON.toJSONString(user3Map));
System.out.println(jsonObject1);
}
// jsonArray 使用 stream 流
public static void test11(){
JSONArray objects = JSON.parseArray(userJsonList);
Map<String, Object> userMap = objects.stream().collect(Collectors.toMap(item -> ((JSONObject) item).getString("name"), item -> item, (key1, key2) -> key1));
Set<String> keySet = userMap.keySet();
for (String key : keySet) {
System.out.println(userMap.get(key).toString());
}
}
}
@AllArgsConstructor
@NoArgsConstructor
@Data
class User3{
private String name;
private Integer age;
private String sex;
}
io流
1 文件
package com.ycy.io;
import java.io.*;
public class FileIo {
public static void main(String[] args) throws IOException {
// createFile();
// test();
test2();
}
// 创建文件
public static void createFile() throws IOException {
File file = new File("D:\\My\\fileTest.txt");
if (!file.exists()){
file.createNewFile();
}
System.out.println(file.length());
System.out.println(file.getAbsolutePath());
System.out.println(file.getAbsoluteFile());
file.delete();
}
// 练习 创建一个文件 写入数据，再读出数据
public static void test() throws IOException {
// 添加文件
File file = new File("D:\\My\\fileTest.txt");
try {
file.createNewFile();
}catch (IOException e){
e.printStackTrace();
}
// 使用字节流写入文件
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(file);
java.lang.String str = "无言独上西楼 月如钩 寂寞梧桐深院锁清秋";
fileOutputStream.write(str.getBytes());
}catch (IOException e){
e.printStackTrace();
}finally {
if (null != fileOutputStream){
fileOutputStream.close();
}
}
// 读取文件
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(file);
byte[] bytes = new byte[1024];
int length = 0;
StringBuffer stringBuffer = new StringBuffer();
while ((length=fileInputStream.read(bytes))!= -1){
stringBuffer.append(new java.lang.String(bytes,0,length));
}
System.out.println(stringBuffer.toString());
}catch (IOException e){
e.printStackTrace();
}finally {
if (null != fileInputStream){
fileInputStream.close();
}
}
file.delete();
}
// 测试使用字符流读取文件
public static void test2() throws IOException {
// 添加文件
File file = new File("D:\\My\\fileTest.txt");
try {
if (!file.exists()){
file.createNewFile();
}
}catch (IOException e){
e.printStackTrace();
}
// 字符流写文件
OutputStreamWriter writer = null;
try {
writer = new OutputStreamWriter(new FileOutputStream(file,true),"UTF8");
String str = "无言独上西楼 月如钩 寂寞梧桐深院锁清秋";
writer.write(str);
// writer.write(str,0,5);
}catch (IOException e){
e.printStackTrace();
}finally {
if (null != writer);
writer.close();
}
// 读文件
InputStreamReader inputStreamReader = null;
try {
inputStreamReader = new InputStreamReader(new FileInputStream(file),"utf8");
char[] chars = new char[1024];
StringBuffer stringBuffer = new StringBuffer();
int length = 0;
while ((length=inputStreamReader.read(chars))!= -1){
stringBuffer.append(new String(chars,0,length));
}
System.out.println(stringBuffer);
}catch (IOException e){
e.printStackTrace();
}finally {
if (null != inputStreamReader){
inputStreamReader.close();
}
}
// file.delete();
}
}
2.读写文件
package com.ycy.io;
import java.io.*;
public class BaseIo {
public static void main(String[] args) throws IOException {
File file = new File("D:/test.txt");
// write(file);
// System.out.println(read(file));
// bufferedWrite(file);
// System.out.println(bufferedRead(file));
writeChar(file);
System.out.println(readChar(file));
// fileWriter(file);
// System.out.println(fileRead(file));
}
// 字节流 写数据
public static void write(File file) throws IOException{
// 创建字节输入流对象
FileOutputStream fileOutputStream = new FileOutputStream(file);
// 定义要输入的文本
String string = "无言独上西楼，月如钩，寂寞梧桐深院锁清秋";
// 写入文件
fileOutputStream.write(string.getBytes());
// 关闭流
fileOutputStream.close();
}
// 字节流 读数据
public static String read(File file) throws IOException{
// 创建字节输入流对象
FileInputStream fileInputStream = new FileInputStream(file);
// 一次性取多少个字节
byte[] bytes = new byte[1024];
// 存储读取的字节
StringBuffer stringBuffer = new StringBuffer();
// 记录读取的字节
int length = 0;
while ((length = fileInputStream.read(bytes)) != -1){
String s = new String(bytes, 0, length);
stringBuffer.append(new String(bytes,0,length));
}
fileInputStream.close();
return stringBuffer.toString();
}
// 字节缓冲流 写数据
public static void bufferedWrite(File file) throws IOException{
// 创建字节缓冲流对象
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file));
// 定义要输入的文本
String string = "无言独上西楼，月如钩，寂寞梧桐深院锁清秋";
// 写入文件
bufferedOutputStream.write(string.getBytes());
// 关闭流
bufferedOutputStream.close();
}
// 字节缓冲流 读数据
public static String bufferedRead(File file) throws IOException{
// 创建字节缓冲输入流对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
// 一次性取多少个字节
byte[] bytes = new byte[1024];
// 存储读取的字节
StringBuffer stringBuffer = new StringBuffer();
// 记录读取的字节
int length = 0;
while ((length = bufferedInputStream.read(bytes)) != -1){
String s = new String(bytes, 0, length);
stringBuffer.append(new String(bytes,0,length));
}
bufferedInputStream.close();
return stringBuffer.toString();
}
// 字符输出流
public static void writeChar(File file) throws IOException{
// 创建字符输出流对象 new FileOutputStream(file ,true) 构造方法添加 第二个参数为true时，会将
// OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file,true),"UTF-8");
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file),"UTF-8");
// 写入数据
// 定义要输入的文本
String string = "无言独上西楼，月如钩，寂寞梧桐深院锁清秋";
outputStreamWriter.write(string);
outputStreamWriter.close();
}
// 字符输入流
public static String readChar(File file) throws IOException{
// 创建字符输出流对象
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file), "UTF-8");
char[] chars = new char[1024];
StringBuffer stringBuffer = new StringBuffer();
// 读取到的字符数组长度，为-1时表示没有数据
int length;
// 循环取数据
while ((length = inputStreamReader.read(chars)) != -1) {
// 将读取的内容转换成字符串
stringBuffer.append(chars, 0, length);
}
// 关闭流
inputStreamReader.close();
return stringBuffer.toString();
}
// 字符便捷类
public static void fileWriter(File file) throws IOException {
FileWriter fileWriter = new FileWriter(file, true);
String str = "无言独上西楼，月如钩，寂寞梧桐深院锁清秋";
fileWriter.write(str);
fileWriter.close();
}
public static String fileRead(File file)throws IOException{
FileReader fileReader = new FileReader(file);
char[] chars = new char[1024];
StringBuffer stringBuffer = new StringBuffer();
int length;
while ((length = fileReader.read(chars))!= -1){
stringBuffer.append(chars,0,length);
}
fileReader.close();
return stringBuffer.toString();
}
}
摘要
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
1476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
