hello_ejb3
hello_ejb3

Java21的新特性

Java语言特性系列

  • Java5的新特性
  • Java6的新特性
  • Java7的新特性
  • Java8的新特性
  • Java9的新特性
  • Java10的新特性
  • Java11的新特性
  • Java12的新特性
  • Java13的新特性
  • Java14的新特性
  • Java15的新特性
  • Java16的新特性
  • Java17的新特性
  • Java18的新特性
  • Java19的新特性
  • Java20的新特性
  • Java21的新特性
  • Java22的新特性

序

本文主要讲述一下Java21的新特性

版本号

java -version
openjdk version "21" 2023-09-19
OpenJDK Runtime Environment (build 21+35-2513)
OpenJDK 64-Bit Server VM (build 21+35-2513, mixed mode, sharing)

从version信息可以看出是build 21+35

特性列表

JEP 430: String Templates (Preview)

在java21之前，字符串拼接或者字符串与表达式组合主要是用StringBuilder、String::format、java.text.MessageFormat，不过可读性都不是太好，java21引入了StringTemplate(java.lang.StringTemplate)来解决这个问题。

@PreviewFeature(feature=PreviewFeature.Feature.STRING_TEMPLATES)
public interface StringTemplate {
	List fragments();
	List values();
	default String interpolate() {
        return StringTemplate.interpolate(fragments(), values());
    }
    default  R
    process(Processor processor) throws E {
        Objects.requireNonNull(processor, "processor should not be null");

        return processor.process(this);
    }

    static String interpolate(List fragments, List values) {
        Objects.requireNonNull(fragments, "fragments must not be null");
        Objects.requireNonNull(values, "values must not be null");
        int fragmentsSize = fragments.size();
        int valuesSize = values.size();
        if (fragmentsSize != valuesSize + 1) {
            throw new IllegalArgumentException("fragments must have one more element than values");
        }
        JavaTemplateAccess JTA = SharedSecrets.getJavaTemplateAccess();
        return JTA.interpolate(fragments, values);
    }

    Processor STR = StringTemplate::interpolate;
    Processor RAW = st -> st;

    @PreviewFeature(feature=PreviewFeature.Feature.STRING_TEMPLATES)
    @FunctionalInterface
    public interface Processor {
    	R process(StringTemplate stringTemplate) throws E;
    	static  Processor of(Function process) {
            return process::apply;
        }

        @PreviewFeature(feature=PreviewFeature.Feature.STRING_TEMPLATES)
        public sealed interface Linkage permits FormatProcessor {
        	MethodHandle linkage(List fragments, MethodType type);
        }
    }
}
 
  
 
   
StringTemplate是个接口，它定义了fragments、values、interpolate、process方法，同时提供了interpolate、process方法的默认实现；同时内置了两个processor，分别是STR和RAW，他们的区别在于RAW可以获取到StringTemplate类型，STR则是StringTemplate执行了interpolate方法之后的结果，获得到的是最终结果String；其基本语法就是用\{}来包含变量或者表达式
 
  
 
  
 
   
RAW示例
 
  
 
  
    @Test
    public void testRaw() {
        int x = 10;
        int y = 20;
        StringTemplate st = RAW."\{x} + \{y} = \{x + y}";
        List fragments = st.fragments();
        List values = st.values();
        log.info("fragments:{}, values:{}, st:{}", fragments, values, st.interpolate());
    }
 
  
 
   
输出fragments:[, + , = , ], values:[10, 20, 30], st:10 + 20 = 30
 
  
 
  
 
   
STR示例
 
  
 
  
    @Test
    public void testStr() {
        String name = "Joan";
        String info = STR."My name is \{name}";
        System.out.println(info);
    }

 
  
 
   
输出My name is Joan
 
  
 
  
 
   
也支持方法调用和表达式
 
  
 
  
    @Test
    public void testStrExpression() {
        String filePath = "tmp.dat";
        File file = new File(filePath);
        String msg = STR. "The file \{ filePath } \{ file.exists() ? "does" : "does not" } exist" ;
        System.out.println(msg);
    }

 
  
 
   
最后输出The file tmp.dat does not exist
 
  
 
  
对于还有格式化需求的，提供了java.util.FMT
 
  
	@Test
    public void testFmt() {
        record Rectangle(String name, double width, double height) {
            double area() {
                return width * height;
            }
        }
        Rectangle[] zone = new Rectangle[] {
                new Rectangle("Alfa", 17.8, 31.4),
                new Rectangle("Bravo", 9.6, 12.4),
                new Rectangle("Charlie", 7.1, 11.23),
        };
        String table = FMT."""
    Description     Width    Height     Area
    %-12s\{zone[0].name}  %7.2f\{zone[0].width}  %7.2f\{zone[0].height}     %7.2f\{zone[0].area()}
    %-12s\{zone[1].name}  %7.2f\{zone[1].width}  %7.2f\{zone[1].height}     %7.2f\{zone[1].area()}
    %-12s\{zone[2].name}  %7.2f\{zone[2].width}  %7.2f\{zone[2].height}     %7.2f\{zone[2].area()}
    \{" ".repeat(28)} Total %7.2f\{zone[0].area() + zone[1].area() + zone[2].area()}
    """;
        System.out.println(table);
    }

 
  
也可以自定义processor
 
  
@Test
    public void testCustomProcessor() {
        var MYJSON = StringTemplate.Processor.of(
                (StringTemplate st) -> com.alibaba.fastjson.JSON.parseObject(st.interpolate())
        );

        String name    = "Joan Smith";
        String phone   = "555-123-4567";
        String address = "1 Maple Drive, Anytown";
        JSONObject doc = MYJSON."""
    {
        "name":    "\{name}",
        "phone":   "\{phone}",
        "address": "\{address}"
    }
    """;
        System.out.println(doc);
    }

 
  
JEP 431: Sequenced Collections
 
  
java21引入了java.util.SequencedCollection、java.util.SequencedMap来统一各类集合的顺序方法方法
 
  
public interface SequencedCollection extends Collection {
	SequencedCollection reversed();
	default void addFirst(E e) {
        throw new UnsupportedOperationException();
    }
    default void addLast(E e) {
        throw new UnsupportedOperationException();
    }
    default E getFirst() {
        return this.iterator().next();
    }
    default E getLast() {
        return this.reversed().iterator().next();
    }
    default E removeFirst() {
        var it = this.iterator();
        E e = it.next();
        it.remove();
        return e;
    }
    default E removeLast() {
        var it = this.reversed().iterator();
        E e = it.next();
        it.remove();
        return e;
    }
}

 
  
 
   
SequencedCollection继承了Collection接口，同时定义了reversed，提供了addFirst、addLast、getFirst、getLast、removeFirst、removeLast的default实现；List、SequencedSet接口都继承了SequencedCollection接口
 
  
 
  
public interface SequencedMap extends Map {
	SequencedMap reversed();
	default Map.Entry firstEntry() {
        var it = entrySet().iterator();
        return it.hasNext() ? new NullableKeyValueHolder<>(it.next()) : null;
    }
    default Map.Entry lastEntry() {
        var it = reversed().entrySet().iterator();
        return it.hasNext() ? new NullableKeyValueHolder<>(it.next()) : null;
    }
    default Map.Entry pollFirstEntry() {
        var it = entrySet().iterator();
        if (it.hasNext()) {
            var entry = new NullableKeyValueHolder<>(it.next());
            it.remove();
            return entry;
        } else {
            return null;
        }
    }
    default Map.Entry pollLastEntry() {
        var it = reversed().entrySet().iterator();
        if (it.hasNext()) {
            var entry = new NullableKeyValueHolder<>(it.next());
            it.remove();
            return entry;
        } else {
            return null;
        }
    }
    default V putFirst(K k, V v) {
        throw new UnsupportedOperationException();
    }
    default V putLast(K k, V v) {
        throw new UnsupportedOperationException();
    }
    default SequencedSet sequencedKeySet() {
        class SeqKeySet extends AbstractMap.ViewCollection implements SequencedSet {
            Collection view() {
                return SequencedMap.this.keySet();
            }
            public SequencedSet reversed() {
                return SequencedMap.this.reversed().sequencedKeySet();
            }
            public boolean equals(Object other) {
                return view().equals(other);
            }
            public int hashCode() {
                return view().hashCode();
            }
        }
        return new SeqKeySet();
    }
    default SequencedCollection sequencedValues() {
        class SeqValues extends AbstractMap.ViewCollection implements SequencedCollection {
            Collection view() {
                return SequencedMap.this.values();
            }
            public SequencedCollection reversed() {
                return SequencedMap.this.reversed().sequencedValues();
            }
        }
        return new SeqValues();
    }
    default SequencedSet> sequencedEntrySet() {
        class SeqEntrySet extends AbstractMap.ViewCollection>
                implements SequencedSet> {
            Collection> view() {
                return SequencedMap.this.entrySet();
            }
            public SequencedSet> reversed() {
                return SequencedMap.this.reversed().sequencedEntrySet();
            }
            public boolean equals(Object other) {
                return view().equals(other);
            }
            public int hashCode() {
                return view().hashCode();
            }
        }
        return new SeqEntrySet();
    }              
}

 
  
 
   
SequencedMap接口继承了Map接口，它定义了reversed方法，同时提供了firstEntry、lastEntry、pollFirstEntry、pollLastEntry、putFirst、putLast、sequencedKeySet、sequencedValues、sequencedEntrySet方法的默认实现
 
  
 
  
此次版本的变动：
 Java21的新特性_第1张图片
 
  
     
   
  • List现在有作为其直接的超级接口，SequencedCollection
    •  
   
  • Deque现在有作为其直接的超级接口，SequencedCollection
    •  
   
  • LinkedHashSet另外实现SequencedSet接口
    •  
   
  • SortedSet现在有作为其直接的超级接口，SequencedSet
    •  
   
  • LinkedHashMap另外实现SequencedMap接口
    •  
   
  • SortedMap现在有作为它的直接超级接口，SequencedMap
    •  
  
 
  
另外Collections还提供了工厂方法用于返回不可变类型
 
  
Collections.unmodifiableSequencedCollection(sequencedCollection)
Collections.unmodifiableSequencedSet(sequencedSet)
Collections.unmodifiableSequencedMap(sequencedMap)

 
  
JEP 439: Generational ZGC
 
  
ZGC分代回收无疑是一个重磅的GC特性，ZGC之前的版本不支持分代回收，此次支持分代回收的话，可以更方便地对年轻代进行收集，提高GC性能。目前是分代与非分代都支持，使用分代则通过-XX:+UseZGC-XX:+ZGenerational开启，后续版本将会把分代设置为默认的，而-XX:-ZGenerational用于开启非分代，最后将会废除非分代的支持，届时ZGenerational参数也就没有作用了。
 
  
JEP 440: Record Patterns
 
  
 
   
JDK19的JEP 405: Record Patterns (Preview)将Record的模式匹配作为第一次preview
 JDK20的JEP 432: Record Patterns (Second Preview)作为第二次preview
 此次在JDK21则作为正式版本发布，使用示例如下
 
  
 
  
record Point(int x, int y) {}

// As of Java 21
static void printSum(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println(x+y);
    }
}

enum Color { RED, GREEN, BLUE }
record ColoredPoint(Point p, Color c) {}
record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}
// As of Java 21
static void printUpperLeftColoredPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
         System.out.println(ul.c());
    }
}

static void printColorOfUpperLeftPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point p, Color c),
                               ColoredPoint lr)) {
        System.out.println(c);
    }
}

 
  
JEP 441: Pattern Matching for switch
 
  
 
   
在JDK14JEP 305: Pattern Matching for instanceof (Preview)作为preview
 在JDK15JEP 375: Pattern Matching for instanceof (Second Preview)作为第二轮的preview
 在JDK16JEP 394: Pattern Matching for instanceof转正
 JDK17引入JEP 406: Pattern Matching for switch (Preview)
 JDK18的JEP 420: Pattern Matching for switch (Second Preview)则作为第二轮preview
 JDK19的JEP 427: Pattern Matching for switch (Third Preview)作为第三轮preview
 JDK20的JEP 433: Pattern Matching for switch (Fourth Preview)作为第四轮preview
 而此次JDK21将Pattern Matching for switch作为正式版本发布，示例如下
 
  
 
  
// Prior to Java 21
static String formatter(Object obj) {
    String formatted = "unknown";
    if (obj instanceof Integer i) {
        formatted = String.format("int %d", i);
    } else if (obj instanceof Long l) {
        formatted = String.format("long %d", l);
    } else if (obj instanceof Double d) {
        formatted = String.format("double %f", d);
    } else if (obj instanceof String s) {
        formatted = String.format("String %s", s);
    }
    return formatted;
}

// As of Java 21
static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

// As of Java 21
static void testFooBarNew(String s) {
    switch (s) {
        case null         -> System.out.println("Oops");
        case "Foo", "Bar" -> System.out.println("Great");
        default           -> System.out.println("Ok");
    }
}

// As of Java 21
static void testStringEnhanced(String response) {
    switch (response) {
        case null -> { }
        case "y", "Y" -> {
            System.out.println("You got it");
        }
        case "n", "N" -> {
            System.out.println("Shame");
        }
        case String s
        when s.equalsIgnoreCase("YES") -> {
            System.out.println("You got it");
        }
        case String s
        when s.equalsIgnoreCase("NO") -> {
            System.out.println("Shame");
        }
        case String s -> {
            System.out.println("Sorry?");
        }
    }
}

// As of Java 21
static void exhaustiveSwitchWithBetterEnumSupport(CardClassification c) {
    switch (c) {
        case Suit.CLUBS -> {
            System.out.println("It's clubs");
        }
        case Suit.DIAMONDS -> {
            System.out.println("It's diamonds");
        }
        case Suit.HEARTS -> {
            System.out.println("It's hearts");
        }
        case Suit.SPADES -> {
            System.out.println("It's spades");
        }
        case Tarot t -> {
            System.out.println("It's a tarot");
        }
    }
}

// As of Java 21
sealed interface Currency permits Coin {}
enum Coin implements Currency { HEADS, TAILS } 

static void goodEnumSwitch1(Currency c) {
    switch (c) {
        case Coin.HEADS -> {    // Qualified name of enum constant as a label
            System.out.println("Heads");
        }
        case Coin.TAILS -> {
            System.out.println("Tails");
        }
    }
}

static void goodEnumSwitch2(Coin c) {
    switch (c) {
        case HEADS -> {
            System.out.println("Heads");
        }
        case Coin.TAILS -> {    // Unnecessary qualification but allowed
            System.out.println("Tails");
        }
    }
}

// As of Java 21
static void testNew(Object obj) {
    switch (obj) {
        case String s when s.length() == 1 -> ...
        case String s                      -> ...
        ...
    }
}

 
  
JEP 442: Foreign Function & Memory API (Third Preview)
 
  
 
   
Foreign Function & Memory (FFM) API包含了两个incubating API
 JDK14的JEP 370: Foreign-Memory Access API (Incubator)引入了Foreign-Memory Access API作为incubator
 JDK15的JEP 383: Foreign-Memory Access API (Second Incubator)Foreign-Memory Access API作为第二轮incubator
 JDK16的JEP 393: Foreign-Memory Access API (Third Incubator)作为第三轮，它引入了Foreign Linker API (JEP 389)
 FFM API在JDK 17的JEP 412: Foreign Function & Memory API (Incubator)作为incubator引入
 FFM API在JDK 18的JEP 419: Foreign Function & Memory API (Second Incubator)作为第二轮incubator
 JDK19的JEP 424: Foreign Function & Memory API (Preview)则将FFM API作为preview API
 JDK20的JEP 434: Foreign Function & Memory API (Second Preview)作为第二轮preview
 JDK21则作为第三轮的preview，使用示例
 
  
 
  
.javac --release 21 --enable-preview ...java --enable-preview ...

// 1. Find foreign function on the C library path
Linker linker          = Linker.nativeLinker();
SymbolLookup stdlib    = linker.defaultLookup();
MethodHandle radixsort = linker.downcallHandle(stdlib.find("radixsort"), ...);
// 2. Allocate on-heap memory to store four strings
String[] javaStrings = { "mouse", "cat", "dog", "car" };
// 3. Use try-with-resources to manage the lifetime of off-heap memory
try (Arena offHeap = Arena.ofConfined()) {
    // 4. Allocate a region of off-heap memory to store four pointers
    MemorySegment pointers
        = offHeap.allocateArray(ValueLayout.ADDRESS, javaStrings.length);
    // 5. Copy the strings from on-heap to off-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = offHeap.allocateUtf8String(javaStrings[i]);
        pointers.setAtIndex(ValueLayout.ADDRESS, i, cString);
    }
    // 6. Sort the off-heap data by calling the foreign function
    radixsort.invoke(pointers, javaStrings.length, MemorySegment.NULL, '\0');
    // 7. Copy the (reordered) strings from off-heap to on-heap
    for (int i = 0; i < javaStrings.length; i++) {
        MemorySegment cString = pointers.getAtIndex(ValueLayout.ADDRESS, i);
        javaStrings[i] = cString.getUtf8String(0);
    }
} // 8. All off-heap memory is deallocated here
assert Arrays.equals(javaStrings,
                     new String[] {"car", "cat", "dog", "mouse"});  // true

 
  
JEP 443: Unnamed Patterns and Variables (Preview)
 
  
Unnamed Patterns and Variables支持用_来替代没有使用的变量声明，比如
 
  
r instanceof Point _
r instanceof ColoredPoint(Point(int x, int _), Color _)
if (r instanceof ColoredPoint(_, Color c)) { ... c ... }
switch (b) {
    case Box(RedBall _), Box(BlueBall _) -> processBox(b);
    case Box(GreenBall _)                -> stopProcessing();
    case Box(_)                          -> pickAnotherBox();
}
int acc = 0;
for (Order _ : orders) {
    if (acc < LIMIT) { 
        ... acc++ ...
    }
}
while (q.size() >= 3) {
    var x = q.remove();
    var _ = q.remove();
    var _ = q.remove(); 
    ... new Point(x, 0) ...
}

 
  
JEP 444: Virtual Threads
 
  
 
   
在JDK19[https://openjdk.org/jeps/425](JEP 425: Virtual Threads (Preview))作为第一次preview
 在JDK20JEP 436: Virtual Threads (Second Preview)作为第二次preview，此版本java.lang.ThreadGroup被永久废弃
 在JDK21版本，Virtual Threads正式发布，与之前版本相比，这次支持了threadlocal，然后也可以通过Thread.Builder来创建，而且也支持threaddump(jcmd  Thread.dump_to_file -format=json )
 
  
 
  
使用示例
 
  
void handle(Request request, Response response) {
    var url1 = ...
    var url2 = ...
 
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        var future1 = executor.submit(() -> fetchURL(url1));
        var future2 = executor.submit(() -> fetchURL(url2));
        response.send(future1.get() + future2.get());
    } catch (ExecutionException | InterruptedException e) {
        response.fail(e);
    }
}
 
String fetchURL(URL url) throws IOException {
    try (var in = url.openStream()) {
        return new String(in.readAllBytes(), StandardCharsets.UTF_8);
    }
}

 
  
 
   
一般用Executors.newVirtualThreadPerTaskExecutor()是想通过池化技术来减少对象创建开销，不过由于虚拟线程相比平台线程更为"廉价"，因而不再需要池化，如果需要控制虚拟线程数则可以使用信号量的方式，因而提供了Thread.Builder来直接创建虚拟线程，示例如下：
 
  
 
  
Thread thread = Thread.ofVirtual().name("duke").unstarted(runnable);
Thread.startVirtualThread（Runnable） 

 
  
JEP 445: Unnamed Classes and Instance Main Methods (Preview)
 
  
未命名的类和实例main方法这个特性可以简化hello world示例，方便java新手入门，示例如下
 
  
        static void main(String[] args) {
            System.out.println("static main with args");
        }

        static void main() {
            System.out.println("static main without args");
        }

        void main(String[] args) {
            System.out.println("main with args");
        }

        void main() {
            System.out.println("main with without args");
        }

 
  
 
   
javac --release 21 --enable-preview Main.javajava --enable-preview Main
 其中main方法选择的优先顺序是static的优于非static的，然后有args的优于没有args的
 
  
 
  
JEP 446: Scoped Values (Preview)
 
  
 
   
Scoped Values在JDK20的JEP 429: Scoped Values (Incubator)作为Incubator
 此次在JDK21作为preview版本
 ScopedValue是一种类似ThreadLocal的线程内/父子线程传递变量的更优方案。ThreadLocal提供了一种无需在方法参数上传递通用变量的方法，InheritableThreadLocal使得子线程可以拷贝继承父线程的变量。但是ThreadLocal提供了set方法，变量是可变的，另外remove方法很容易被忽略，导致在线程池场景下很容易造成内存泄露。ScopedValue则提供了一种不可变、不拷贝的方案，即不提供set方法，子线程不需要拷贝就可以访问父线程的变量。具体使用如下：
 
  
 
  
class Server {
  public final static ScopedValue LOGGED_IN_USER = ScopedValue.newInstance();
 
  private void serve(Request request) {
    // ...
    User loggedInUser = authenticateUser(request);
    ScopedValue.where(LOGGED_IN_USER, loggedInUser)
               .run(() -> restAdapter.processRequest(request));
    // ...
  }
}

 
  
 
   
通过ScopedValue.where可以绑定ScopedValue的值，然后在run方法里可以使用，方法执行完毕自行释放，可以被垃圾收集器回收
 
  
 
  
JEP 448: Vector API (Sixth Incubator)
 
  
 
   
JDK16引入了JEP 338: Vector API (Incubator)提供了jdk.incubator.vector来用于矢量计算
 JDK17进行改进并作为第二轮的incubatorJEP 414: Vector API (Second Incubator)
 JDK18的JEP 417: Vector API (Third Incubator)进行改进并作为第三轮的incubator
 JDK19的JEP 426:Vector API (Fourth Incubator)作为第四轮的incubator
 JDK20的JEP 438: Vector API (Fifth Incubator)作为第五轮的incubator
 而JDK21则作为第六轮的incubator，使用示例如下
 
  
 
  
static final VectorSpecies SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

 
  
JEP 449: Deprecate the Windows 32-bit x86 Port for Removal
 
  
废弃了对Windows 32-bit x86 (x86-32)的移植，以便后续版本删除
 
  
JEP 451: Prepare to Disallow the Dynamic Loading of Agents
 
  
对将代理动态加载到正在运行的 JVM 中时发出警告，后续版本将不允许动态加载agent。
 
  
 
   
在 JDK 9 及更高版本中，可以通过-XX:-EnableDynamicAgentLoading禁止动态加载agent。
 在 JDK 21 中，允许动态加载agent，但 JVM 会在发生时发出警告。例如：
 
  
 
  
WARNING: A {Java,JVM TI} agent has been loaded dynamically (file:/u/bob/agent.jar)
WARNING: If a serviceability tool is in use, please run with -XX:+EnableDynamicAgentLoading to hide this warning
WARNING: If a serviceability tool is not in use, please run with -Djdk.instrument.traceUsage for more information
WARNING: Dynamic loading of agents will be disallowed by default in a future release

 
  
若要允许工具动态加载agent而不发出警告，用户必须在命令行上使用-XX:+EnableDynamicAgentLoading
 
  
JEP 452: Key Encapsulation Mechanism API
 
  
Key Encapsulation Mechanism(KEM)是一种现代加密技术，它使用非对称或公钥加密来保护对称密钥。传统的方法是使用公钥加密一个随机生成的对称密钥，但这需要填充，并且可能难以证明安全。相反，KEM利用公钥的属性派生一个相关的对称密钥，这不需要填充。
 
  
 
   
此次新增了javax.crypto.KEM、javax.crypto.KEMSpi
 
  
 
  
package javax.crypto;

public class DecapsulateException extends GeneralSecurityException;

public final class KEM {

    public static KEM getInstance(String alg)
        throws NoSuchAlgorithmException;
    public static KEM getInstance(String alg, Provider p)
        throws NoSuchAlgorithmException;
    public static KEM getInstance(String alg, String p)
        throws NoSuchAlgorithmException, NoSuchProviderException;

    public static final class Encapsulated {
        public Encapsulated(SecretKey key, byte[] encapsulation, byte[] params);
        public SecretKey key();
        public byte[] encapsulation();
        public byte[] params();
    }

    public static final class Encapsulator {
        String providerName();
        int secretSize();           // Size of the shared secret
        int encapsulationSize();    // Size of the key encapsulation message
        Encapsulated encapsulate();
        Encapsulated encapsulate(int from, int to, String algorithm);
    }

    public Encapsulator newEncapsulator(PublicKey pk)
            throws InvalidKeyException;
    public Encapsulator newEncapsulator(PublicKey pk, SecureRandom sr)
            throws InvalidKeyException;
    public Encapsulator newEncapsulator(PublicKey pk, AlgorithmParameterSpec spec,
                                        SecureRandom sr)
            throws InvalidAlgorithmParameterException, InvalidKeyException;

    public static final class Decapsulator {
        String providerName();
        int secretSize();           // Size of the shared secret
        int encapsulationSize();    // Size of the key encapsulation message
        SecretKey decapsulate(byte[] encapsulation) throws DecapsulateException;
        SecretKey decapsulate(byte[] encapsulation, int from, int to,
                              String algorithm)
                throws DecapsulateException;
    }

    public Decapsulator newDecapsulator(PrivateKey sk)
            throws InvalidKeyException;
    public Decapsulator newDecapsulator(PrivateKey sk, AlgorithmParameterSpec spec)
            throws InvalidAlgorithmParameterException, InvalidKeyException;

}

 
  
 
   
它主要是提供了newEncapsulator、newDecapsulator方法，使用示例如下
 
  
 
  
// Receiver side
KeyPairGenerator g = KeyPairGenerator.getInstance("ABC");
KeyPair kp = g.generateKeyPair();
publishKey(kp.getPublic());

// Sender side
KEM kemS = KEM.getInstance("ABC-KEM");
PublicKey pkR = retrieveKey();
ABCKEMParameterSpec specS = new ABCKEMParameterSpec(...);
KEM.Encapsulator e = kemS.newEncapsulator(pkR, specS, null);
KEM.Encapsulated enc = e.encapsulate();
SecretKey secS = enc.key();
sendBytes(enc.encapsulation());
sendBytes(enc.params());

// Receiver side
byte[] em = receiveBytes();
byte[] params = receiveBytes();
KEM kemR = KEM.getInstance("ABC-KEM");
AlgorithmParameters algParams = AlgorithmParameters.getInstance("ABC-KEM");
algParams.init(params);
ABCKEMParameterSpec specR = algParams.getParameterSpec(ABCKEMParameterSpec.class);
KEM.Decapsulator d = kemR.newDecapsulator(kp.getPrivate(), specR);
SecretKey secR = d.decapsulate(em);

// secS and secR will be identical

 
  
JEP 453: Structured Concurrency (Preview)
 
  
 
   
在JDK19的JEP 428: Structured Concurrency (Incubator)作为第一次incubator
 在JDK20的JEP 437: Structured Concurrency (Second Incubator)作为第二次incubator
 此次在JDK21则作为preview，使用示例如下
 
  
 
  
Response handle() throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Supplier  user  = scope.fork(() -> findUser());
        Supplier order = scope.fork(() -> fetchOrder());

        scope.join()            // Join both subtasks
             .throwIfFailed();  // ... and propagate errors

        // Here, both subtasks have succeeded, so compose their results
        return new Response(user.get(), order.get());
    }
}

 
  
细项解读
 
  
上面列出的是大方面的特性，除此之外还有一些api的更新及废弃，主要见JDK 21 Release Notes，这里举几个例子。
 
  
添加项
 
  
     
   
  • Math.clamp() and StrictMath.clamp() Methods (JDK-8301226)
    •  
   
  • New String indexOf(int,int,int) and indexOf(String,int,int) Methods to Support a Range of Indices (JDK-8302590)
    •  
   
  • New splitWithDelimiters() Methods Added to String and java.util.regex.Pattern (JDK-8305486)
    •  
   
  • System.exit() and Runtime.exit() Logging (JDK-8301627)
    •  
   
  • The java.net.http.HttpClient Is Now AutoCloseable (JDK-8267140)
    •  
   
  • New StringBuilder and StringBuffer repeat Methods (JDK-8302323)
    •  
   
  • Last Resort G1 Full GC Moves Humongous Objects (JDK-8191565)
    •  
  
 
  
移除项
 
  
     
   
  • Removed SECOM Trust System’s RootCA1 Root Certificate (JDK-8295894)
    •  
   
  • java.io.File’s Canonical Path Cache Is Removed (JDK-8300977)
    •  
   
  • Removal of the java.compiler System Property (JDK-8041676)
    •  
   
  • The java.lang.Compiler Class Has Been Removed (JDK-8205129)
    •  
   
  • Remove the JAR Index Feature (JDK-8302819)
    •  
   
  • Removal of G1 Hot Card Cache (JDK-8225409)
    •  
   
  • Obsolete Legacy HotSpot Parallel Class Loading Workaround Option -XX:+EnableWaitForParallelLoad Is Removed (JDK-8298469)
    •  
   
  • The MetaspaceReclaimPolicy Flag has Been Obsoleted (JDK-8302385)
    •  
  
 
  
废弃项
 
  
     
   
  • Deprecate GTK2 for Removal (JDK-8280031)
    •  
   
  • Deprecate JMX Subject Delegation and the JMXConnector.getMBeanServerConnection(Subject) Method for Removal (JDK-8298966)
    •  
  
 
  
重要bug修复
 
  
     
   
  • Error Computing the Amount of Milli- and Microseconds between java.time.Instants (JDK-8307466)
    •  
   
  • Disallow Extra Semicolons Between “import” Statements (JDK-8027682)
    •  
  
 
  
已知问题
 
  
     
   
  • JVM May Crash or Malfunction When Using ZGC and Non-Default ObjectAlignmentInBytes (JDK-8312749)
    •  
   
  • Validations on ZIP64 Extra Fields (JDK-8313765)
    •  
   
  • java.util.regex.MatchResult Might Throw StringIndexOutOfBoundsException on Regex Patterns Containing Lookaheads and Lookbehinds (JDK-8132995)
    •  
   
  • JVM May Hang When Using Generational ZGC if a VM Handshake Stalls on Memory (JDK-8311981)
    •  
  
 
  
其他事项
 
  
     
   
  • ObjectInputStream::readObject() Should Handle Negative Array Sizes without Throwing NegativeArraySizeExceptions (JDK-8306461)
    •  
   
  • File::listRoots Changed to Return All Available Drives on Windows (JDK-8208077)
    •  
   
  • Thread.sleep(millis, nanos) Is Now Able to Perform Sub-Millisecond Sleeps (JDK-8305092)
    •  
   
  • FileChannel.transferFrom Extends File if Called to Transfer Bytes to the File (JDK-8303260)
    •  
   
  • Clarification of the Default Charset Initialization with file.encoding (JDK-8300916)
    •  
   
  • java.util.Formatter May Return Slightly Different Results on double and float (JDK-8300869)
    •  
   
  • JVM TI ThreadStart and ThreadEnd Events Not Sent for Virtual Threads (JDK-8307399)
    •  
   
  • Add final Keyword to Some Static Methods (JDK-8302696)
    •  
  
 
  
小结
 
  
Java21主要有如下几个特性
 
  
     
   
  • JEP 430: String Templates (Preview)
    •  
   
  • JEP 431: Sequenced Collections
    •  
   
  • JEP 439: Generational ZGC
    •  
   
  • JEP 440: Record Patterns
    •  
   
  • JEP 441: Pattern Matching for switch
    •  
   
  • JEP 442: Foreign Function & Memory API (Third Preview)
    •  
   
  • JEP 443: Unnamed Patterns and Variables (Preview)
    •  
   
  • JEP 444: Virtual Threads
    •  
   
  • JEP 445: Unnamed Classes and Instance Main Methods (Preview)
    •  
   
  • JEP 446: Scoped Values (Preview)
    •  
   
  • JEP 448: Vector API (Sixth Incubator)
    •  
   
  • JEP 449: Deprecate the Windows 32-bit x86 Port for Removal
    •  
   
  • JEP 451: Prepare to Disallow the Dynamic Loading of Agents
    •  
   
  • JEP 452: Key Encapsulation Mechanism API
    •  
   
  • JEP 453: Structured Concurrency (Preview)
    •  
  
 
  
 
   
其中JEP 439: Generational ZGC及JEP 444: Virtual Threads应属于重磅级的特性，而JEP 430: String Templates (Preview)、JEP 431: Sequenced Collections、JEP 440: Record Patterns及JEP 441: Pattern Matching for switch则在语言表达力层面上有了增强
 另外java21是继JDK 17之后最新的长期支持(LTS)版本，将获得至少8年的支持。
 
  
 
  
doc
 
  
     
   
  • JDK 21 Features
    •  
   
  • JDK 21 Release Notes
    •  
   
  • Consolidated JDK 21 Release Notes
    •  
   
  • Java SE 21 deprecated-list
    •  
   
  • The Arrival of Java 21
    •  
   
  • JDK 21 G1/Parallel/Serial GC changes
    •  
   
  • Java 21, the Next LTS Release, Delivers Virtual Threads, Record Patterns and Pattern Matching
    •  
   
  • JDK 21 and JDK 22: What We Know So Far
    •  
   
  • Java 21 New Features: “The ZGC is generational and will further improve performance for suitable applications”
    •  
   
  • Java 21 is Available Today, And It’s Quite the Update
    •  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(redis,数据库,java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解
                        秋刀prince
mysqlmysql数据库
                        
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                                
  • [星球大战]阿纳金的背叛
                                    comsci

                                    
     
      本来杰迪圣殿的长老是不同意让阿纳金接受训练的......... 
 
    但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会 
 
    所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院 
 
   
    
                                
    • 
                                
  • 看懂它，你就可以任性的玩耍了！
                                    aijuans
JavaScript
                                    
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 
function jClass(b
    
                                
    • 
                                
  • Java常用工具包 Jodd
                                    Kai_Ge
javajodd
                                    
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！  写道   Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb  
Jodd 被分成众多模块，按需选择，其中 
 
  工具类模块有：  
  
   jodd-core    &nb
    
                                
    • 
                                
  • SpringMvc下载
                                    120153216
springMVC
                                    
    @RequestMapping(value = WebUrlConstant.DOWNLOAD)
	public void download(HttpServletRequest request,HttpServletResponse response,String fileName) {
		OutputStream os = null;
		InputStream is = null;

    
                                
    • 
                                
  • Python 标准异常总结
                                    2002wmj
python
                                    
    Python标准异常总结  
    AssertionError 断言语句（assert）失败   AttributeError 尝试访问未知的对象属性   EOFError 用户输入文件末尾标志EOF（Ctrl+d）   FloatingPointError 浮点计算错误   GeneratorExit generator.close()方法被调用的时候   ImportError 导入模块失
    
                                
    • 
                                
  • SQL函数返回临时表结构的数据用于查询
                                    357029540
SQL Server
                                    
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
    
                                
    • 
                                
  • java 时间格式化 | 比较大小| 时区 个人笔记
                                    7454103
javaeclipsetomcatcMyEclipse
                                    
    个人总结！ 不当之处多多包含！ 
 
  引用   1.0 如何设置 tomcat 的时区： 
         位置：(catalina.bat---JAVA_OPTS  下面加上) 
         set JAVA_OPT
    
                                
    • 
                                
  • 时间获取Clander的用法
                                    adminjun
Clander时间
                                    
    /** 
   * 得到几天前的时间 
   * @param d 
   * @param day 
   * @return 
   */ 
  public static Date getDateBefore(Date d,int day){ 
   Calend
    
                                
    • 
                                
  • JVM初探与设置
                                    aijuans
java
                                    
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
    
                                
    • 
                                
  • SQL中ON和WHERE的区别
                                    avords

                                    
    SQL中ON和WHERE的区别       
数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com     在使用left jion时，on和where条件的区别如下：    1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。  
    
                                
    • 
                                
  • 说说自信
                                    houxinyou
工作生活
                                    
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗? 
  
  
无论工作还
    
                                
    • 
                                
  • WEBLOGIC事务超时设置
                                    bijian1013
weblogicjta事务超时
                                    
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 
统计数据出错!
原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
    
                                
    • 
                                
  • 两年已过去，再看该如何快速融入新团队
                                    bingyingao
java互联网融入架构新团队
                                    
    偶得的空闲，翻到了两年前的帖子 
该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。 
 
    时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
    
                                
    • 
                                
  • 【Spark七十七】Spark分析Nginx和Apache的access.log
                                    bit1129
apache
                                    
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式： 
  
Nginx的access.log解析正则表达式 
  
val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
    
                                
    • 
                                
  • Erlang patch
                                    bookjovi
erlang
                                    
    Totally five patchs committed to erlang otp, just small patchs. 
IMO, erlang really is a interesting programming language, I really like its concurrency feature. 
but the functional programming style 
    
                                
    • 
                                
  • log4j日志路径中加入日期
                                    bro_feng
javalog4j
                                    
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 
实现方式 
log4j: 
<appender name="serviceLog"
		class="org.apache.log4j.RollingFileAppender">
      	<param name="Encoding" v
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-桥接模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html
 * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
    
                                
    • 
                                
  • windows7下SVN和Eclipse插件安装
                                    chenyu19891124
eclipse插件
                                    
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
    
                                
    • 
                                
  • [转帖]工作流引擎设计思路
                                    comsci
设计模式工作应用服务器workflow企业应用
                                    
     作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 
 
================================================================================= 
 
自开博以来不断有朋友来探讨工作流引擎该如何
    
                                
    • 
                                
  • Linux 查看内存，CPU及硬盘大小的方法
                                    daizj
linuxcpu内存硬盘大小
                                    
    一、查看CPU信息的命令 
 
[root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" 
model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz 
model name : 
    
                                
    • 
                                
  • linux 踢出在线用户
                                    dongwei_6688
linux
                                    
    两个步骤： 
1.用w命令找到要踢出的用户，比如下面： 
  
[root@localhost ~]# w
 18:16:55 up 39 days,  8:27,  3 users,  load average: 0.03, 0.03, 0.00
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
    
                                
    • 
                                
  • 放手吧,就像不曾拥有过一样
                                    dcj3sjt126com

                                    
    内容提要：   
静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
    
                                
    • 
                                
  • php二进制安全的含义
                                    dcj3sjt126com
PHP
                                    
    PHP里，有string的概念。
string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。
byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。
特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
    
                                
    • 
                                
  • Linux下禁用T440s，X240的一体化触摸板(touchpad)
                                    gashero
linuxThinkPad触摸板
                                    
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。 
  
Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。 
  
实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
    
                                
    • 
                                
  • graph_dfs
                                    hcx2013
Graph
                                    
    package edu.xidian.graph;

class MyStack {
	private final int SIZE = 20;
	private int[] st;
	private int top;

	public MyStack() {
		st = new int[SIZE];
		top = -1;
	}

	public void push(i
    
                                
    • 
                                
  • Spring4.1新特性——Spring核心部分及其他
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • 配置HiveServer2的安全策略之自定义用户名密码验证
                                    liyonghui160com

                                    
      
  
具体从网上看 
  
http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication 
  
 
  
   
   LDAP Authentication using OpenLDAP 
   Setting 
    
                                
    • 
                                
  • 一位30多的程序员生涯经验总结
                                    pda158
编程工作生活咨询
                                    
    1.客户在接触到产品之后，才会真正明白自己的需求。 
　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 
　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
    
                                
    • 
                                
  • 分布式web服务架构的演变
                                    自由的奴隶
linuxWeb应用服务器互联网
                                    
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
    
                                
    • 
                                
  • 初探Druid连接池之二——慢SQL日志记录
                                    xingsan_zhang
日志连接池druid慢SQL
                                    
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。 
  
1.applicationContext.xml中增加如下配置： 
<bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
    
                                
    •