Copy and rename in the same time (also change filename, not only path):

cp program3.cpp homework6.cpp

Rename only:

mv program3.cpp homework6.cpp

In an -exec predicate, the symbol {} represents a path that is being considered, starting at one of the starting-point directories designated in the command. Example: start/dir2/Preview.json. You can form other file names by either prepending or appending characters, but whether that makes sense depends on the details. In your case, appending produces commands such as

cp start/dir2/Preview.json start/dir2/Preview.jsonQA

which is a plausible command in the event that start/dir2/Preview.json exists. But cp does not automatically create directories in the destination path, so the result of prepending characters ...

cp start/dir2/Preview.json QAstart/dir2/Preview.json

... is not as likely to be accepted -- it depends on directory QAstart/dir2 existing.

I think what you're actually looking for may be cp commands of the form ...

cp start/dir2/Preview.json start/dir2/QAPreview.json

... but find cannot do this by itself.

For more flexibility in handling the file names discovered by find, pipe its output into another command. If you want to pass them as command-line arguments to another command, then you can interpose the xargs command to achieve that. The command on the receiving end of the pipe can be a shell function or a compound command if you wish.

For example,

# Using ./* instead of * ensures that file names beginning with - will not
# be misinterpreted as options:
find ./* -type f -name 'Preview.json' |
  while IFS= read -r name; do  # Read one line and store it in variable $name
    # the destination name needs to be computed differently if the name
    # contains a / character (the usual case) than if it doesn't:
    case "${name}" in
      */*) cp "${name}" "${name%/*}/QA${name##*/}" ;;
      *)   cp "${name}" "QA${name}" ;;
    esac
  done

Note that that assumes that none of your directory names contain newline characters (the read command would split up newline-containing filenames). That's a reasonably safe assumption, but not absolutely safe.

Of course, you would generally want to have that in a script, not to try to type it on the fly on the command line.

cp takes a one or more files as source and a destination. The if the destination is a filename and not a directory, and there is only one source file then the file is renamed.

$ mkdir /tmp/a /tmp/b
$ echo test > /tmp/a/somefile
$ cp /tmp/a/somefile /tmp/b/          # creates /tmp/b/somefile
$ cp /tmp/a/somefile /tmp/b/somefile2 # creates /tmp/b/somefile2

No need for bash here, any standard sh interpreter implementation will do:

#! /bin/sh -
ret=0
for file do
  dir=$(dirname -- "$file")
  case dir/ # handle / and // specially
  esac
  base=$(basename -- "$file")
  name=${base%.*}
  name=${name:-$base} # don't consider .bashrc the extension in /foo/.bashrc
  ext=${base#"$name"}
  new_file={name}_copyfile" "$new_file" || ret=$?
done
exit "$ret"

(assumes the file and dir names don't end in newline characters).

(of course, that will also work with bash since bash is one of those standard sh interpreters.)

For a bash-specific solution, you could try:

#! /bin/bash -
ret=0
re='^((.*/)?[^/])(([^/]*)(\.))?([^/]*)/*$'
for file do
  if [[ $file =~ $re ]]; then
    if [[ ${BASH_REMATCH[5]} ]]; then
      suffix=_copy.${BASH_REMATCH[6]}
    else
      suffix=${BASH_REMATCH[6]}_copy
    fi
    cp -- "$file" "${BASH_REMATCH[1]}${BASH_REMATCH[4]}$suffix" || ret=$?
  else
    printf >&2 '%s\n' "$0: Error: refusing to copy $file"
    ret=1
 fi
done
exit "$ret"

It's possible without writing a script ("bash file"), but not without using a loop:

for f in *.ext ; do cp -- "$f" "$(basename "$f" .ext)" ; done

basename can be used to remove the suffix.

for f in *.html; do cp $f ${f%.html}.php; done

You can use the following:

for file in *
do
   name="${file%.*}"
   extension="${file##*.}"
   cp $file ${name}_my${extension}
done

Note that ${file%.*} returns the file name without extension, so that from hello.txt you get hello. By doing ${file%.*}_my.txt you then get from hello.txt -> hello_my.txt.

Regarding the extension, extension="${file##*.}" gets it. It is based on the question Extract filename and extension in bash.

Having below structure:

├── destdir
└── srcdir
    ├── dir1
    │   └── with space.csv
    ├── dir2
    │   └── infile.csv
    └── dir3
        └── otherfile.Csv

running the command:

find "/path/to/srcdir" -type f -iname '*.csv' -exec sh -c '
    path="${1%/*}"; filename="${1##*/}";
    echo cp -nv "${1}" "/path/to/destdir/${path##*/}.${filename}" ' sh_cp {} \;

will produce output as following (running in dry mode):

cp -v /path/to/srcdir/dir2/infile.csv     /path/to/destdir/dir2.infile.csv
cp -v /path/to/srcdir/dir1/with space.csv /path/to/destdir/dir1.file with space.csv
cp -v /path/to/srcdir/dir3/otherfile.Csv  /path/to/destdir/dir3.otherfile.Csv

if we remove the echo in front of the cp command (which is used for dry-run) to get copy &rename affective, you will get below structure:

├── destdir
│   ├── dir1.with space.csv
│   ├── dir2.infile.csv
│   └── dir3.otherfile.Csv
└── srcdir
    ├── dir1
    │   └── with space.csv
    ├── dir2
    │   └── infile.csv
    └── dir3
        └── otherfile.Csv

note that if there was a same filename and same parent directory name say in sub-directories, it will overwrite with latest file found by the find command, that's why I used -n for the cp command to prevent that, so it will not copy that same file, be noted about that.

Explanation:

find "/path/to/srcdir" -type f -iname '*.csv' -exec sh -c '...' sh_cp {} \;

find files with .csv suffix (ignore-case) recursively and -execute the inline-sh-script for each sh -c '...' we name it sh_cp; the {} is the substitution of the filepath that find command finds it and we pass to our script and that is accessible on $1 or ${1} parameter.

• ${1%/*}: cuts shortest-suffix from the ${1} parameter (known Shell-Parameter-Expansion), as said above ${1} is the filepath and with this we drop the filename + last / from the filepath and keep only path and store in the path variable.

  ${1}      --> /path/to/srcdir/dir2/infile.csv
  ${1%/*}   --> /path/to/srcdir/dir2
  

• ${1##*/}: cuts longest-prefix from the ${1} parameter; with this we remove path from the filepath and keep only filename and store in the filename variable.

  ${1}      --> /path/to/srcdir/dir2/infile.csv
  ${1##*/}  --> infile.csv
  

  and accordinlgy:

  path                    --> /path/to/srcdir/dir2
  ${path##*/}             --> dir2
  ${filename}             --> infile.csv
  ${path##*/}.${filename} --> dir2.infile.csv
  

tips:

xYz='to-test/path/to/srcdir/dir2/infile.csv'
${xYz%/*}   --> to-test/path/to/srcdir/dir2
${xYz%%/*}  --> to-test
${xYz#*/}   --> path/to/srcdir/dir2/infile.csv
${xYz#*/}   --> infile.csv