Using stream API to set strings all lowercase but capitalize first letter












12














I have a List<String> and through only using the stream API I was settings all strings to lowercase, sorting them from smallest string to largest and printing them. The issue I'm having is capitalizing the first letter of the string.



Is that something I do through .stream().map()?



public class Main {

public static void main(String args) {

List<String> list = Arrays.asList("SOmE", "StriNgs", "fRom", "mE", "To", "yOU");
list.stream()
.map(n -> n.toLowerCase())
.sorted((a, b) -> a.length() - b.length())
.forEach(n -> System.out.println(n));;

}

}


Output:



me
to
you
some
from
strings


Desired output:



Me
To
You
Some
From
Strings









share|improve this question





























    12














    I have a List<String> and through only using the stream API I was settings all strings to lowercase, sorting them from smallest string to largest and printing them. The issue I'm having is capitalizing the first letter of the string.



    Is that something I do through .stream().map()?



    public class Main {

    public static void main(String args) {

    List<String> list = Arrays.asList("SOmE", "StriNgs", "fRom", "mE", "To", "yOU");
    list.stream()
    .map(n -> n.toLowerCase())
    .sorted((a, b) -> a.length() - b.length())
    .forEach(n -> System.out.println(n));;

    }

    }


    Output:



    me
    to
    you
    some
    from
    strings


    Desired output:



    Me
    To
    You
    Some
    From
    Strings









    share|improve this question



























      12












      12








      12


      1





      I have a List<String> and through only using the stream API I was settings all strings to lowercase, sorting them from smallest string to largest and printing them. The issue I'm having is capitalizing the first letter of the string.



      Is that something I do through .stream().map()?



      public class Main {

      public static void main(String args) {

      List<String> list = Arrays.asList("SOmE", "StriNgs", "fRom", "mE", "To", "yOU");
      list.stream()
      .map(n -> n.toLowerCase())
      .sorted((a, b) -> a.length() - b.length())
      .forEach(n -> System.out.println(n));;

      }

      }


      Output:



      me
      to
      you
      some
      from
      strings


      Desired output:



      Me
      To
      You
      Some
      From
      Strings









      share|improve this question















      I have a List<String> and through only using the stream API I was settings all strings to lowercase, sorting them from smallest string to largest and printing them. The issue I'm having is capitalizing the first letter of the string.



      Is that something I do through .stream().map()?



      public class Main {

      public static void main(String args) {

      List<String> list = Arrays.asList("SOmE", "StriNgs", "fRom", "mE", "To", "yOU");
      list.stream()
      .map(n -> n.toLowerCase())
      .sorted((a, b) -> a.length() - b.length())
      .forEach(n -> System.out.println(n));;

      }

      }


      Output:



      me
      to
      you
      some
      from
      strings


      Desired output:



      Me
      To
      You
      Some
      From
      Strings






      java java-8 mapping java-stream capitalization






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited Dec 12 '18 at 9:19









      Andrew Tobilko

      26k104284




      26k104284










      asked Dec 11 '18 at 23:14









      Devin

      1318




      1318
























          3 Answers
          3






          active

          oldest

          votes


















          13














          Something like this should suffice:



           list.stream()
          .map(n -> n.toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
          .forEachOrdered(n -> System.out.println(n));



          1. note that I've changed the comparator, which is essentially the idiomatic approach to do it.

          2. I've added a map operation after sorting to uppercase the first letter.






          share|improve this answer























          • Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
            – Devin
            Dec 11 '18 at 23:19






          • 2




            @Devin you can chain as many intermediate operations as you like.
            – Aomine
            Dec 11 '18 at 23:19






          • 3




            Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
            – Holger
            Dec 12 '18 at 7:47










          • @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
            – Viktor Mellgren
            Dec 12 '18 at 8:58



















          14














          list.stream()
          .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);


          For readability, the line performing capitalisation should be moved into a method,



          public class StringUtils {
          public static String capitalise(String s) {
          return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
          }
          }


          so you can refer to it via an eloquent method reference:



          list.stream()
          .map(StringUtils::capitalise)
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);





          share|improve this answer



















          • 2




            This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
            – Alex Reinking
            Dec 12 '18 at 6:08






          • 3




            @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
            – Aomine
            Dec 12 '18 at 6:43





















          3














          You can use WordUtils::capitalizeFully from Apache Commons Lang for this.



           list.stream()
          .sorted(Comparator.comparingInt(String::length))
          .map(WordUtils::capitalizeFully)
          .forEach(System.out::println);





          share|improve this answer



















          • 1




            OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
            – Andrew Tobilko
            Dec 11 '18 at 23:39






          • 1




            @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
            – fastcodejava
            Dec 11 '18 at 23:42






          • 4




            New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
            – Alex Reinking
            Dec 12 '18 at 6:10













          Your Answer






          StackExchange.ifUsing("editor", function () {
          StackExchange.using("externalEditor", function () {
          StackExchange.using("snippets", function () {
          StackExchange.snippets.init();
          });
          });
          }, "code-snippets");

          StackExchange.ready(function() {
          var channelOptions = {
          tags: "".split(" "),
          id: "1"
          };
          initTagRenderer("".split(" "), "".split(" "), channelOptions);

          StackExchange.using("externalEditor", function() {
          // Have to fire editor after snippets, if snippets enabled
          if (StackExchange.settings.snippets.snippetsEnabled) {
          StackExchange.using("snippets", function() {
          createEditor();
          });
          }
          else {
          createEditor();
          }
          });

          function createEditor() {
          StackExchange.prepareEditor({
          heartbeatType: 'answer',
          autoActivateHeartbeat: false,
          convertImagesToLinks: true,
          noModals: true,
          showLowRepImageUploadWarning: true,
          reputationToPostImages: 10,
          bindNavPrevention: true,
          postfix: "",
          imageUploader: {
          brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
          contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
          allowUrls: true
          },
          onDemand: true,
          discardSelector: ".discard-answer"
          ,immediatelyShowMarkdownHelp:true
          });


          }
          });














          draft saved

          draft discarded


















          StackExchange.ready(
          function () {
          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53733777%2fusing-stream-api-to-set-strings-all-lowercase-but-capitalize-first-letter%23new-answer', 'question_page');
          }
          );

          Post as a guest















          Required, but never shown

























          3 Answers
          3






          active

          oldest

          votes








          3 Answers
          3






          active

          oldest

          votes









          active

          oldest

          votes






          active

          oldest

          votes









          13














          Something like this should suffice:



           list.stream()
          .map(n -> n.toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
          .forEachOrdered(n -> System.out.println(n));



          1. note that I've changed the comparator, which is essentially the idiomatic approach to do it.

          2. I've added a map operation after sorting to uppercase the first letter.






          share|improve this answer























          • Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
            – Devin
            Dec 11 '18 at 23:19






          • 2




            @Devin you can chain as many intermediate operations as you like.
            – Aomine
            Dec 11 '18 at 23:19






          • 3




            Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
            – Holger
            Dec 12 '18 at 7:47










          • @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
            – Viktor Mellgren
            Dec 12 '18 at 8:58
















          13














          Something like this should suffice:



           list.stream()
          .map(n -> n.toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
          .forEachOrdered(n -> System.out.println(n));



          1. note that I've changed the comparator, which is essentially the idiomatic approach to do it.

          2. I've added a map operation after sorting to uppercase the first letter.






          share|improve this answer























          • Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
            – Devin
            Dec 11 '18 at 23:19






          • 2




            @Devin you can chain as many intermediate operations as you like.
            – Aomine
            Dec 11 '18 at 23:19






          • 3




            Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
            – Holger
            Dec 12 '18 at 7:47










          • @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
            – Viktor Mellgren
            Dec 12 '18 at 8:58














          13












          13








          13






          Something like this should suffice:



           list.stream()
          .map(n -> n.toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
          .forEachOrdered(n -> System.out.println(n));



          1. note that I've changed the comparator, which is essentially the idiomatic approach to do it.

          2. I've added a map operation after sorting to uppercase the first letter.






          share|improve this answer














          Something like this should suffice:



           list.stream()
          .map(n -> n.toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
          .forEachOrdered(n -> System.out.println(n));



          1. note that I've changed the comparator, which is essentially the idiomatic approach to do it.

          2. I've added a map operation after sorting to uppercase the first letter.







          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Dec 12 '18 at 7:48

























          answered Dec 11 '18 at 23:16









          Aomine

          39.7k73770




          39.7k73770












          • Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
            – Devin
            Dec 11 '18 at 23:19






          • 2




            @Devin you can chain as many intermediate operations as you like.
            – Aomine
            Dec 11 '18 at 23:19






          • 3




            Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
            – Holger
            Dec 12 '18 at 7:47










          • @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
            – Viktor Mellgren
            Dec 12 '18 at 8:58


















          • Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
            – Devin
            Dec 11 '18 at 23:19






          • 2




            @Devin you can chain as many intermediate operations as you like.
            – Aomine
            Dec 11 '18 at 23:19






          • 3




            Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
            – Holger
            Dec 12 '18 at 7:47










          • @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
            – Viktor Mellgren
            Dec 12 '18 at 8:58
















          Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
          – Devin
          Dec 11 '18 at 23:19




          Yes that works, thank you! I was unaware I could use Map multiple times for the same stream.
          – Devin
          Dec 11 '18 at 23:19




          2




          2




          @Devin you can chain as many intermediate operations as you like.
          – Aomine
          Dec 11 '18 at 23:19




          @Devin you can chain as many intermediate operations as you like.
          – Aomine
          Dec 11 '18 at 23:19




          3




          3




          Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
          – Holger
          Dec 12 '18 at 7:47




          Keep in mind that forEach makes no ordering guaranties, so to be sure to see the elements in the sorted order, you have to use forEachOrdered.
          – Holger
          Dec 12 '18 at 7:47












          @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
          – Viktor Mellgren
          Dec 12 '18 at 8:58




          @Devin, use as many intermediate operations (filter/map/distinct/sorted/peek) as you need. After you have applied a terminal method (reduce/collect/foreach) you have "ended" the stream.
          – Viktor Mellgren
          Dec 12 '18 at 8:58













          14














          list.stream()
          .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);


          For readability, the line performing capitalisation should be moved into a method,



          public class StringUtils {
          public static String capitalise(String s) {
          return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
          }
          }


          so you can refer to it via an eloquent method reference:



          list.stream()
          .map(StringUtils::capitalise)
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);





          share|improve this answer



















          • 2




            This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
            – Alex Reinking
            Dec 12 '18 at 6:08






          • 3




            @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
            – Aomine
            Dec 12 '18 at 6:43


















          14














          list.stream()
          .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);


          For readability, the line performing capitalisation should be moved into a method,



          public class StringUtils {
          public static String capitalise(String s) {
          return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
          }
          }


          so you can refer to it via an eloquent method reference:



          list.stream()
          .map(StringUtils::capitalise)
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);





          share|improve this answer



















          • 2




            This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
            – Alex Reinking
            Dec 12 '18 at 6:08






          • 3




            @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
            – Aomine
            Dec 12 '18 at 6:43
















          14












          14








          14






          list.stream()
          .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);


          For readability, the line performing capitalisation should be moved into a method,



          public class StringUtils {
          public static String capitalise(String s) {
          return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
          }
          }


          so you can refer to it via an eloquent method reference:



          list.stream()
          .map(StringUtils::capitalise)
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);





          share|improve this answer














          list.stream()
          .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase())
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);


          For readability, the line performing capitalisation should be moved into a method,



          public class StringUtils {
          public static String capitalise(String s) {
          return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
          }
          }


          so you can refer to it via an eloquent method reference:



          list.stream()
          .map(StringUtils::capitalise)
          .sorted(Comparator.comparingInt(String::length))
          .forEach(System.out::println);






          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Dec 11 '18 at 23:44

























          answered Dec 11 '18 at 23:19









          Andrew Tobilko

          26k104284




          26k104284








          • 2




            This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
            – Alex Reinking
            Dec 12 '18 at 6:08






          • 3




            @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
            – Aomine
            Dec 12 '18 at 6:43
















          • 2




            This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
            – Alex Reinking
            Dec 12 '18 at 6:08






          • 3




            @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
            – Aomine
            Dec 12 '18 at 6:43










          2




          2




          This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
          – Alex Reinking
          Dec 12 '18 at 6:08




          This will exhibit better locality than the accepted answer, which splits the map on either side of the sort.
          – Alex Reinking
          Dec 12 '18 at 6:08




          3




          3




          @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
          – Aomine
          Dec 12 '18 at 6:43






          @AlexReinking While a agree with you, I just want to point out that the only reason why I’ve decided against using one map operation at the time of posting was to keep the logic on each intermediate operation short and easy see to follow thus making it easier for the OP. Remember at the end of the day, the OP seems like a new person to the Streams API, talking about anything else is a bonus but takes things away from the their main point which is to simply uppercase the first character. btw, seems like now the OP knows that one can use more than one “same” intermediate operation :).
          – Aomine
          Dec 12 '18 at 6:43













          3














          You can use WordUtils::capitalizeFully from Apache Commons Lang for this.



           list.stream()
          .sorted(Comparator.comparingInt(String::length))
          .map(WordUtils::capitalizeFully)
          .forEach(System.out::println);





          share|improve this answer



















          • 1




            OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
            – Andrew Tobilko
            Dec 11 '18 at 23:39






          • 1




            @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
            – fastcodejava
            Dec 11 '18 at 23:42






          • 4




            New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
            – Alex Reinking
            Dec 12 '18 at 6:10


















          3














          You can use WordUtils::capitalizeFully from Apache Commons Lang for this.



           list.stream()
          .sorted(Comparator.comparingInt(String::length))
          .map(WordUtils::capitalizeFully)
          .forEach(System.out::println);





          share|improve this answer



















          • 1




            OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
            – Andrew Tobilko
            Dec 11 '18 at 23:39






          • 1




            @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
            – fastcodejava
            Dec 11 '18 at 23:42






          • 4




            New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
            – Alex Reinking
            Dec 12 '18 at 6:10
















          3












          3








          3






          You can use WordUtils::capitalizeFully from Apache Commons Lang for this.



           list.stream()
          .sorted(Comparator.comparingInt(String::length))
          .map(WordUtils::capitalizeFully)
          .forEach(System.out::println);





          share|improve this answer














          You can use WordUtils::capitalizeFully from Apache Commons Lang for this.



           list.stream()
          .sorted(Comparator.comparingInt(String::length))
          .map(WordUtils::capitalizeFully)
          .forEach(System.out::println);






          share|improve this answer














          share|improve this answer



          share|improve this answer








          edited Dec 12 '18 at 7:15









          Peter Mortensen

          13.5k1983111




          13.5k1983111










          answered Dec 11 '18 at 23:38









          fastcodejava

          23.9k19109162




          23.9k19109162








          • 1




            OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
            – Andrew Tobilko
            Dec 11 '18 at 23:39






          • 1




            @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
            – fastcodejava
            Dec 11 '18 at 23:42






          • 4




            New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
            – Alex Reinking
            Dec 12 '18 at 6:10
















          • 1




            OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
            – Andrew Tobilko
            Dec 11 '18 at 23:39






          • 1




            @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
            – fastcodejava
            Dec 11 '18 at 23:42






          • 4




            New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
            – Alex Reinking
            Dec 12 '18 at 6:10










          1




          1




          OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
          – Andrew Tobilko
          Dec 11 '18 at 23:39




          OP wants to capitalise only the first letter. Besides, you didn't mention where WordUtils comes from...
          – Andrew Tobilko
          Dec 11 '18 at 23:39




          1




          1




          @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
          – fastcodejava
          Dec 11 '18 at 23:42




          @AndrewTobilko WordUtils::capitalizeFully does just that. I have mentioned where WordUtils comes from now.
          – fastcodejava
          Dec 11 '18 at 23:42




          4




          4




          New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
          – Alex Reinking
          Dec 12 '18 at 6:10






          New code should use the commons-text version of this method instead, as the commons-lang one has been deprecated.
          – Alex Reinking
          Dec 12 '18 at 6:10




















          draft saved

          draft discarded




















































          Thanks for contributing an answer to Stack Overflow!


          • Please be sure to answer the question. Provide details and share your research!

          But avoid



          • Asking for help, clarification, or responding to other answers.

          • Making statements based on opinion; back them up with references or personal experience.


          To learn more, see our tips on writing great answers.





          Some of your past answers have not been well-received, and you're in danger of being blocked from answering.


          Please pay close attention to the following guidance:


          • Please be sure to answer the question. Provide details and share your research!

          But avoid



          • Asking for help, clarification, or responding to other answers.

          • Making statements based on opinion; back them up with references or personal experience.


          To learn more, see our tips on writing great answers.




          draft saved


          draft discarded














          StackExchange.ready(
          function () {
          StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53733777%2fusing-stream-api-to-set-strings-all-lowercase-but-capitalize-first-letter%23new-answer', 'question_page');
          }
          );

          Post as a guest















          Required, but never shown





















































          Required, but never shown














          Required, but never shown












          Required, but never shown







          Required, but never shown

































          Required, but never shown














          Required, but never shown












          Required, but never shown







          Required, but never shown







          Popular posts from this blog

          If I really need a card on my start hand, how many mulligans make sense? [duplicate]

          Alcedinidae

          Can an atomic nucleus contain both particles and antiparticles? [duplicate]