1.获取不带扩展名的文件名
1
2
3
4
5
| public static String getFileNameWithoutExtension(File file) {
String name = file.getName();
int lastIndexOf = name.lastIndexOf('.');
return lastIndexOf == -1 ? name : name.substring(0, lastIndexOf);
}
|
2.删除目录及目录下的所有文件
1
2
3
4
5
6
7
8
|
public void delDir(Path directory) {
try {
Files.walk(directory).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
} catch (Exception e) {
e.printStackTrace();
}
}
|
3.解压缩文件
将sourceZipFilePath.zip文件解压缩到targetDir目里。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public void unZipFile(String sourceZipFilePath, String targetDirPath) {
new File(targetDirPath).mkdirs();
try (ZipFile zip = new ZipFile(sourceZipFilePath,Charset.forName("GBK"))) {
Enumeration enums = zip.entries();
while (enums.hasMoreElements()) {
ZipEntry entry = (ZipEntry) enums.nextElement();
try(
BufferedInputStream bufferis = new BufferedInputStream(zip.getInputStream(entry));
BufferedOutputStream bufferos = new BufferedOutputStream(
new FileOutputStream(sourceDir + "\\" + entry.getName()));
){
byte[] b = new byte[1024];
int len = 0;
while ((len = bufferis.read(b)) != -1) {
bufferos.write(b, 0, len);
}
}
}
} catch (IOException e) {
LOGGER.log(Level.ERROR, "文件解压失败。");
e.printStackTrace();
}
}
|
4.压缩文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| public void zipFile(List<String> sourceFile, String targetFile) {
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(targetFile), Charset.forName("GBK"))) {
for (String f1 : sourceFile) {
if (new File(f1).exists()) {
try (FileInputStream f = new FileInputStream(f1)) {
ZipEntry zipEntry = new ZipEntry(new File(f1).getName());
zos.putNextEntry(zipEntry);
byte[] buffer = new byte[1024];
int len;
while ((len = f.read(buffer)) > 0) {
zos.write(buffer, 0, len);
}
}
}
}
} catch (Exception e) {
LOGGER.log(Level.ERROR, targetFile + "文件压缩失败。");
e.printStackTrace();
}
LOGGER.log(Level.INFO, targetFile + "文件压缩完成。");
}
|
5.判断几天前的日期
1
2
3
4
5
6
7
8
9
10
|
Date date = new Date();
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_YEAR, -6);
Date sixDaysAgo = calendar.getTime();
System.out.println("六天前的日期是: " + sixDaysAgo);
|
6.读取带有命名空间的XML文件，并输出字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public void exportXmlContent(String id,String uml) {
InputSource inputSource = new InputSource(uml);
try {
String xmiNamespacePrefix = "xmi";
String xmiNamespaceUri = "http://www.omg.org/XMI";
xpath.setNamespaceContext(new NamespaceContextImpl(xmiNamespaceUri, xmiNamespacePrefix));
XPath xpath = XPathFactory.newInstance().newXPath();
String xpathExpress = "//packagedElement[@xmi:id=\"" + id + "\"]";
Node node = (Node) xpath.evaluate(xpathExpress, inputSource, XPathConstants.NODE);
System.out.println(node.getNodeName() + "#"+node.getAttributes().getNamedItem("xmi:id") ;
StringWriter sw = new StringWriter();
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
t.transform(new DOMSource(node), new StreamResult(sw));
System.out.println(sw.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
|
7.stream
(1)filter 过滤(查找)元素
函数语法：
Stream<TreeElement> java.util.stream.Stream.filter(Predicate<? super TreeElement> predicate)
(a)filter(判断是否需要的元素).collect(保存为新的List输出).
1
2
3
4
5
6
7
8
9
10
|
List<TreeElement> tlist1=tlist.stream().filter(x->"name".equals(x.getName()))
.collect(Collectors.toList());
User match = users.stream().filter((user) -> user.getId() == 1).findAny().get();
List<String> list = Arrays.asList("aa", "bb", "", "cc");
List<String> filtered = list.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
String str = filtered.stream().collect(Collectors.joining(","));
|
(b)字符串数组(fileNames)中获取指定的元素(.msnotation)。如果为null，返回空字符串；不为null，返回指定字符。
1
2
| String[] fileNames=new File(targetDir).list();
String ret=Stream.of(fileNames).filter(x->x.contains(".msnotation")).findFirst().orElseGet(()->"");
|
(2)map 遍历元素转换成新元素
map()方法是流（Stream）类中的一个中间操作方法，它接受一个函数作为参数，并将该函数应用于流中的每个元素，然后返回一个新的流，其中包含由该函数的结果组成的元素。
1
2
3
| List<Integer> list = Arrays.asList(1, 3, 4, 99, 20);
List<Integer> squaresList = list .stream().map( i -> i*i).distinct().collect(Collectors.toList());
|
(3)collect 保存数据集
(一般与map、filter联用，放在最后作为新数据保存。)
函数语法：
List<TreeElement> java.util.stream.Stream.collect(Collector<? super TreeElement, Object, List<TreeElement>> collector)
把数据流保存到新的数组或集合中。
1
2
3
4
5
6
7
| Map<String, Stream> map = new HashMap<String, Stream>();
map.put("001", new Stream("张三","西安"));
map.put("002", new Stream("李四","铜川"));
List<Map<String, Stream>> list = new ArrayList()
list.add(map);
List<Stream> streams = list.stream().map(item -> item.get("001")).collect(Collectors.toList());
Map<String, Stream> aqglEmpVoMap = streams .stream().collect(Collectors.toMap(Stream::getEmpId, Stream-> Stream));
|
(4)summaryStatistics 输出最大、最小、平均值
1
2
3
| List<Integer> list = Arrays.asList(1, 3, 4, 99, 20);
IntSummaryStatistics statistics = list.stream().mapToInt(x -> x).summaryStatistics();
|
(5)集合中交集、差集、并集
1
2
3
4
5
6
7
8
9
10
11
12
13
|
List<String> list1 = Arrays.asList("阿卫", "阿辉", "阿杰", "阿成");
List<String> list2 = Arrays.asList("阿悦", "阿楠", "阿洁", "阿锋");
List<String> collect = list1.stream().filter(list2::contains).collect(Collectors.toList());
List<String> list3 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
list3 = list2.stream().filter(item -> !list1.contains(item)).collect(toList());
List<String> listAll = list1.parallelStream().collect(Collectors.toList());
List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
listAll.addAll(listAll2);
List<String> listAllDistinct = listAll.stream().distinct().collect(Collectors.toList());
|
(6)Map转List
1
2
3
4
5
6
7
8
9
10
| Map<String,String> map = new HashMap<>(3);
map.put("600519","贵州茅台");
map.put("601398","工商银行");
map.put("300750","宁德时代");
List<Object> list1 = map.entrySet().stream().map(ent ->ent.getKey()+":"+ent.getValue()).collect(Collectors.toList());
List<Object> list2 = map.entrySet().stream().map(ent -> ent.getKey()).collect(Collectors.toList());
List<Object> list3 = map.entrySet().stream().map(ent -> ent.getValue()).collect(Collectors.toList());
list1.forEach(listFor -> System.out.println(listFor));
System.out.println("map数据格式:" + map);
System.out.println("list数据格式:" + list1);
|
(7)List转Map
1
2
3
4
5
6
7
8
| Stream streamTest = new Stream("张三","西安","13345");
List<Stream> list1 = new ArrayList<>();
list1.add(streamTest);
Map result = list1.stream().collect(Collectors.toMap(p -> p.getIdcard(), p -> p.getName(), (k1, k2) -> k1));
Map<String, String> result1 = list1.stream().collect(Collectors.toMap(Stream::getIdcard, Stream::getName));
|
8.反射调用
示例静态类
1
2
3
4
5
6
7
| class MyClass {
public static String DATA="静态字段数据";
public static String myStaticMethod(int number, String text) {
return "Number: " + number + ", Text: " + text;
}
}
|
(1)调用带参数有返回值的静态方法
转换对象类型(用instanceof判断)：MyClass mc=MyClass.cast(Class对象);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) {
try {
Class<?> clazz = Class.forName("com.example.MyClass");
Method method = clazz.getMethod("myStaticMethod", int.class, String.class);
Object result = method.invoke(null, 42, "Hello");
System.out.println("Return value: " + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
(2)静态字段
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| Field field = clazz.getDeclaredField("LOADED_RESOURCESET");
import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) {
try {
Class<?> clazz = Class.forName("com.example.MyClass");
Field field = clazz.getDeclaredField("DATA");
String str=(String)field.get(null);
System.out.println("Return value: " + str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
9.Xml文件调用
Node 类型可以直接转换成Element类型，用于处理元素的属性设置。
1
2
3
4
5
6
7
8
9
10
11
| XPathFactory xpathFactory = XPathFactory.newInstance();
xpath = xpathFactory.newXPath();
URL xmlpath = AXMLFactory.class.getClassLoader().getResource("Browser.xml");
inputSource = new InputSource(xmlpath.toString());
String xpathExpress ="//Elements/Element[@name='Package']";
NodeList nodeList = xpath.evaluate(xpathExpress, inputSource,XPathConstants.NODESET);
for(int i=0;i<nodeList.getLength();i++) {
Node node=nodeList.item(i);
Element el=(Element)node;
System.out.println(node.getNodeName()+";"+node.getNodeValue()+";"+el.getAttribute("name"));
}
|
10.Comparator排序
(1)先按sort字段排序，再中文名称排序。
1
2
3
4
5
|
Collator collator = Collator.getInstance(java.util.Locale.CHINA);
teList.sort(Comparator.<TreeElement>comparingDouble((obj -> Double.parseDouble(obj.getSort()))).
thenComparing((a,b)->collator.compare(a.getName(), b.getName())));
|
(2)先分组排序，再每个组内按中文排序
1
2
3
4
5
6
7
8
9
|
Collator collator = Collator.getInstance(java.util.Locale.CHINA);
Map<String, List<TreeElement>> map = treeList.stream()
.collect(Collectors.groupingBy(TreeElement::getModelTypeCnName));
map.forEach((key,value)->value.sort((a,b)->collator.compare(a.getName(), b.getName())));
map=map.entrySet().stream().sorted(Map.Entry.comparingByKey(collator)).collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (oldVal, newVal) -> oldVal, LinkedHashMap::new));
|
11. java规范
1.包声明
2.导入声明
3.类或接口声明
4.常量声量
5.字段声明(按照普通字段、静态字段；再按照private、protected、public)
6.构造方法或初始块
7.方法声明(按照普通方法、静态方法)
8.内部类声明
示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| package com.example.myapp;
import java.util.List;
import java.util.Map;
import java.io.IOException; // 根据需要添加其他导入语句
public class MyClass {
// 1.常量声明部分（如果有的话）
public static final int MAX_SIZE = 100; // 常量通常是大写字母命名。
// 2.字段声明部分（非静态字段）
private int id;
// 3.静态字段声明部分（如果有的话）例如：单例实例等。例如：instance等。
public static MyClass instance; // 静态字段通常排在非静态字段之后。例如：instance等。
// 构造方法或初始化块部分（如果有的话）例如：构造方法等。例如：构造方法等。
public MyClass() {
|
