你可以维护一个计数器变量，它在每次执行内部循环时递增：

int counter = 0;
List<String> combinations = new ArrayList<>();

for (char c1 = 'a'; c1 <= 'z'; c1++) {
    for (char c2 = 'a'; c2 <= 'z'; c2++) {
        for (char c3 = 'a'; c3 <= 'z'; c3++) {
            String combo = "" + c1 + c2 + c3;
            System.out.println(combo);
            combinations.add(combo);
            ++counter;
        }
    } 
}

System.out.println("total number of combinations is " + counter);  // 17576

这是一种替代实现。

IntStream个代码点

我建议在处理单个字符时，养成使用code points整数的习惯，而不要使用遗留类型char。作为一个16位值，char在物理上无法表示大多数字符。
我们可以从IntStream生成从a到z（97到122）的代码点范围。Character.toString( codePoint )方法从我们的码位整数生成一个单字符String对象。

List < String > characters =
        IntStream
                .rangeClosed( "a".codePointAt( 0 ) , "z".codePointAt( 0 ) )  // ( 97 inclusive, 122 inclusive )
                .mapToObj( Character :: toString )
                .toList();

characters.toString（）= [a、B、c、d、e、f、g、h、i、j、k、l、m、n、o、p、q、r、s、t、u、v、w、x、y、z]
将三个组合字符的每个String收集到List中。

List < String > combinations = new ArrayList <>( characters.size() ^ 3 );

然后使用for-each语法对源列表进行三次嵌套循环，对所需输出的每个位置循环一次。

for ( String firstCharacter : characters )
{
    for ( String secondCharacter : characters )
    {
        for ( String thirdCharacter : characters )
        {
            combinations.add( firstCharacter + secondCharacter + thirdCharacter );
        }
    }
}

调用List#size可以得到你想要的计数。虽然数学上我们知道计数应该是（26 ^ 3）= 17，576。

System.out.println( combinations.size() + " combinations = " + combinations );

运行时。
17576个组合= [aaa，aab，aac，aad，aae，aaf，…zzw，zzx，zzy，zzz]

使用Stream#flatMap进行一行操作

我们甚至可以使用Holger的注解中令人印象深刻的代码将代码减少到一行。
关键部分是对Stream#flatMap的调用，用于从一个值生成多个值。引用Javadoc：
flatMap（）操作的作用是对流的元素应用一对多转换，然后将结果元素展平到新的流中。
顺便说一下，concat是一个static方法。考虑到流上的其他fluent风格的方法，这似乎有点奇怪。如果好奇，请参阅this Question。
因此，我们首先将代码点流转换为Strings流，每个流包含一个字符。对于我们的第一个字符，我们为第二个字符创建了一堆代码点，这些代码点被转换为String对象。我们为第二个字符中的每一个再次调用flatMap，每个字符生成另一个代码点流，这些代码点被转换为第三个位置的String对象。从那里，第一个、第二个和第三个字符组合成一个结果字符串，我们将其收集到最终结果中，即不可修改的List< String >。
我们得到了上面看到的17,576个组合。

List < String > combinations =
        IntStream
                .rangeClosed( "a".codePointAt( 0 ) , "z".codePointAt( 0 ) )
                .mapToObj( Character :: toString )
                .flatMap(
                        first ->
                                IntStream
                                        .rangeClosed( "a".codePointAt( 0 ) , "z".codePointAt( 0 ) )
                                        .mapToObj( Character :: toString )
                                        .flatMap( second ->
                                                IntStream
                                                        .rangeClosed( "a".codePointAt( 0 ) , "z".codePointAt( 0 ) )
                                                        .mapToObj( third -> first + second + Character.toString( third ) )
                                        )
                )
                .toList();

多组输入

上面的代码假设我们有一个单一的字符范围来混合和匹配。请注意，我们可以合并多个范围。只需在传递一对流时调用Stream.concat。
在这个例子中，我们混合并匹配小写字母ab沿着大写字母AB。对于在三个位置中使用的总共四个字符，我们期望4^3 = 64个组合。

List < String > combinations =
        IntStream
                .concat(
                        IntStream.rangeClosed( "a".codePointAt( 0 ) , "b".codePointAt( 0 ) ) ,
                        IntStream.rangeClosed( "A".codePointAt( 0 ) , "B".codePointAt( 0 ) )
                )
                .mapToObj( Character :: toString )
                .flatMap(
                        first ->
                                IntStream
                                        .concat(
                                                IntStream.rangeClosed( "a".codePointAt( 0 ) , "b".codePointAt( 0 ) ) ,
                                                IntStream.rangeClosed( "A".codePointAt( 0 ) , "B".codePointAt( 0 ) )
                                        )
                                        .mapToObj( Character :: toString )
                                        .flatMap( second ->
                                                IntStream
                                                        .concat(
                                                                IntStream.rangeClosed( "a".codePointAt( 0 ) , "b".codePointAt( 0 ) ) ,
                                                                IntStream.rangeClosed( "A".codePointAt( 0 ) , "B".codePointAt( 0 ) )
                                                        )
                                                        .mapToObj( third -> first + second + Character.toString( third ) )
                                        )
                )
                .toList();

64种组合。toString（）= [aaa，aab，aaA，aaB，阿坝，abb，abA，abB，aAa，aAb，aAA，aAB，aBa，aBb，aBA，aBB，baa，bab，baA，baB，bba，bbb，bbA，bbB，bAa，bAb，bAA，bAB、bBa、bBb、bBA、bBB、Aaa、Aab、AaA、AaB、Aba、Abb、AbA、AbB、AAa、AAb、AAA、AAB、ABa、ABb、ABA、ABB、Baa、Bab、BaA、BaB、Bba、Bbb、BbA、BbB、BAa、BAb、BAA、BAB、BBa、BBb、BBA、BBB]

int n = 26; //no. of alphabet which is fix number
int p = 3;  //no. of alphabet we require in one combination like aaa,abc,bbb....
System.out.print(Math.pow(n,p));

有关公式的解释，请阅读以下描述，这将有所帮助

**Easy mathematic formula**
    
    ***(fix number)^(no. of element in each combination)***
    
    It is just like no. of total combination of  when we toss a coin , when we throw two dice in probability.
    
    here each combination contains 3 alphabets so , let's take each alphabet from different pool(p1 , p2 , p3).
    
    p1  p2 p3
    __ ___ __
    a   a  a
    b   b  b
    c   c  c
    d   d  d
    .   .  .
    .   .  .
    .   .  .
    
    so here first take 1st alphabet 'a' from p1(pool1) and then take each alphabet from p2(pool2) so our result be like **aa,ab,ac,ad.....** . here we can see that when we take only 'a' then it creates 26 different combination. likewise each character of pool1(p1) has its own 26 different combination (like 'b' has 'ba','bb','bc'...  also c has'ca','cb','cc' and so on). 
    
    so total combination we can make from first two pool is 26*26.
    
    now let see how our new pool (new combinated pool) look likes...
    
    new pool**    **p3**
_____________     ________
    aa               a
    ab               b
    ac               c
    ad               d
    .                .
    .                .
    .                z
    .               ====
    zz              26
    =====
    26*26 
    
    now let's do the same process between **new pool** and **p3** , so our final result is (new pool characters)*(p3's characters)=[26**26]*26=17576

我曾经有一个项目，我想生成一个“绑定代码”，并将其分配给客户订单中的所有盒子。箱子由拣货员打包，然后放置在传送带上，传送带最终送入单个脊柱，然后前往装运部门，在装运部门，每个承运人将箱子物理绑定在一起（由订单编号和承运人绑定，因为部分订单可能是过夜的，其余订单可能是5天的）。传送带进料经常导致订单的箱子在到达运输部门之前被分离。为了减轻运输员收集相关箱子的任务（按订单/承运人），我想在复杂的运输标签的左上角包含一个大的3个字符的字母值。该值将在视觉上表示订单/承运人组合，使得店员在视觉上（快速且准确地）定位所有相关箱子而不必检查每个箱子的复杂标签来辨别它们的关系。
例如：AAA、AAB、AAC、BAA、ZZZ
因此，生成运输标签的应用程序需要为每个订单/承运商创建此值。每个唯一的组合使控制计数器递增。然后使用该计数器来生成字符值。在达到最大值之后，控制编号被回收，差距足以确保在工作日期间没有重叠。
这是我使用的逻辑。也许，你会发现它的良好价值，为这个问题或其他任何人寻求做类似的。当然，如果需要多于3个字母字符，则可以容易地调整逻辑。

目标：

将控制编号转换为3个字母字符（即AAA至ZZZ）
即26^3 = 17576个组合（注意：确保这是足够的字符，以在再循环之前提供足够的间隙）
数值范围：0至17575（从零开始）

步骤：

1. Apply Modulo 26 to Number and convert Remainder to 3rd-pos character (__#)
2. Apply Modulo 26 to Quotient from prior step and convert Remainder to 2nd-pos character (_#_)
3. Apply Modulo 26 to Quotient from prior step and convert Remainder to 1st-pos character (#__)

换算表：

ABCDEFGHIJKLMNOPQRSTUVWXYZ
    00000000001111111111222222
    01234567890123456789012345

运行时示例：

17575

17575 mod 26 = 675 R25 (25 = "Z") 3rd pos
    675   mod 26 =  25 R25 (25 = "Z") 2nd pos
    25    mod 26 =   0 R25 (25 = "Z") 1st pos
    Answer: ZZZ

0

0 mod 26 = 0 R0 (0 = "A") 3rd pos (__#)
    0 mod 26 = 0 R0 (0 = "A") 2nd pos (_#_)
    0 mod 26 = 0 R0 (0 = "A") 1st pos (#__)
    Answer: AAA

1

676

676 mod 26 = 26 R0 (0 = "A") 3rd pos (__#)
    26  mod 26 =  1 R0 (0 = "A") 2nd pos (_#_)
    1   mod 26 =  0 R1 (1 = "B") 1st pos (#__)
    Answer: BAA

971

971 mod 26 = 37 R9  (9  = "J") 3rd pos
    37  mod 26 =  1 R11 (11 = "L") 2nd pos
    1   mod 26 =  0 R1  (1  = "B") 1st pos
    Answer: BLJ

顺便说一句，我还禁止了顽皮的组合（例如：TIT），利用预设列表来跳过不期望的首字母缩略词。
模数计算器：https://www.calculatorsoup.com/calculators/math/modulo-calculator.php
致上，
保利·D